// Generated from CommandLineGrammar.g4 by ANTLR 4.2

  package gatperdut.chato.core.interpreter.grammar.generated;
  
  import gatperdut.chato.core.interpreter.grammar.comminfo.CommandInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.CommandInfo.CommandType;
  import gatperdut.chato.core.interpreter.grammar.comminfo.indexedword.IndexedWord;
  import gatperdut.chato.core.interpreter.grammar.comminfo.indexedword.IndexedWord.RefType;
  import gatperdut.chato.core.interpreter.grammar.comminfo.ManipulationInfo.ManipulationType;
  import gatperdut.chato.core.interpreter.grammar.comminfo.FoodInfo.ConsumptionType;
  import gatperdut.chato.core.interpreter.grammar.comminfo.SetsInfo.SetsOperation;
  
  import gatperdut.chato.core.interpreter.grammar.comminfo.CommunicationInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.LookInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.ThrowInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.GoInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.ItemTransferInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.LookInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.EmoteInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.SpeakInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.ManipulationDoorInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.ManipulationContainerInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.SpillInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.FillInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.EmptyInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.WearInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.RemoveInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.StatusInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.SkillsInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.ListItemTemplatesInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.FoodInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.InvInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.HelpInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.CraftInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.SetsInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.SetInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.SetInfo.SetType;
  import gatperdut.chato.core.interpreter.grammar.comminfo.SwitchInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.QuitInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.DocumentInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.ScoreInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.HitInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.FleeInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.StopInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.JunkInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.ExitsInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.ShutdownInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.COIRInfo;
  import gatperdut.chato.core.interpreter.grammar.comminfo.MudStatsInfo;

  import gatperdut.chato.constants.CSConstantsMovement.Direction;
  

import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class CommandLineGrammarParser extends Parser {
	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		SAY=1, TELL=2, SHOUT=3, GO_NORTH=4, GO_EAST=5, GO_SOUTH=6, GO_WEST=7, 
		GO_UP=8, GO_DOWN=9, GET=10, PUT=11, DROP=12, GIVE=13, SPILL=14, FILL=15, 
		EMPTY=16, EXITS=17, SPEAK=18, THROW=19, EAT=20, DRINK=21, WEAR=22, REMOVE=23, 
		STATUS=24, SKILLS=25, SET=26, PACIFIST=27, ACCEPTGIVE=28, ON=29, OFF=30, 
		LOOK=31, HIT=32, FLEE=33, STOP=34, OPEN=35, CLOSE=36, LOCK=37, UNLOCK=38, 
		SWITCH=39, INVENTORY=40, DOCUMENT=41, HELP=42, MERGE=43, SPLIT=44, CRAFT=45, 
		SCORE=46, JUNK=47, A_COIR=48, QUIT=49, A_SHUTDOWN=50, A_LISTITEMTEMPLATES=51, 
		A_MUDSTATS=52, ADMIN=53, TILDE=54, STAR=55, OPEN_B=56, CLOSE_B=57, DOT=58, 
		AT=59, WORD=60, INTEGER=61, PUNCTUATION=62, WS=63;
	public static final String[] tokenNames = {
		"<INVALID>", "SAY", "TELL", "SHOUT", "GO_NORTH", "GO_EAST", "GO_SOUTH", 
		"GO_WEST", "GO_UP", "GO_DOWN", "GET", "PUT", "DROP", "GIVE", "SPILL", 
		"FILL", "EMPTY", "EXITS", "SPEAK", "THROW", "EAT", "DRINK", "WEAR", "REMOVE", 
		"STATUS", "SKILLS", "SET", "PACIFIST", "ACCEPTGIVE", "'on'", "OFF", "LOOK", 
		"HIT", "FLEE", "STOP", "OPEN", "CLOSE", "LOCK", "UNLOCK", "SWITCH", "INVENTORY", 
		"DOCUMENT", "HELP", "MERGE", "SPLIT", "'c:'", "SCORE", "JUNK", "'coir'", 
		"QUIT", "'sd'", "'lit'", "'ms'", "'a:'", "'~'", "'*'", "'('", "')'", "'.'", 
		"'@'", "WORD", "INTEGER", "PUNCTUATION", "WS"
	};
	public static final int
		RULE_command = 0, RULE_direction = 1, RULE_tell = 2, RULE_say = 3, RULE_shout = 4, 
		RULE_get = 5, RULE_getRoom = 6, RULE_getContainer = 7, RULE_put = 8, RULE_drop = 9, 
		RULE_give = 10, RULE_look = 11, RULE_eat = 12, RULE_drink = 13, RULE_lookAt = 14, 
		RULE_lookIn = 15, RULE_lookWorn = 16, RULE_fill = 17, RULE_spill = 18, 
		RULE_empty = 19, RULE_switchHands = 20, RULE_hurl = 21, RULE_craft = 22, 
		RULE_emote = 23, RULE_speak = 24, RULE_exits = 25, RULE_open = 26, RULE_openDoor = 27, 
		RULE_openContainer = 28, RULE_close = 29, RULE_closeDoor = 30, RULE_closeContainer = 31, 
		RULE_lock = 32, RULE_lockDoor = 33, RULE_lockContainer = 34, RULE_unlock = 35, 
		RULE_unlockDoor = 36, RULE_unlockContainer = 37, RULE_sets = 38, RULE_merge = 39, 
		RULE_split = 40, RULE_hit = 41, RULE_flee = 42, RULE_stop = 43, RULE_wear = 44, 
		RULE_remove = 45, RULE_status = 46, RULE_skills = 47, RULE_set = 48, RULE_help = 49, 
		RULE_inventory = 50, RULE_document = 51, RULE_score = 52, RULE_junk = 53, 
		RULE_quit = 54, RULE_adminActions = 55, RULE_a_lit = 56, RULE_a_mudStats = 57, 
		RULE_a_coir = 58, RULE_a_shutdown = 59, RULE_bracketedEmote = 60, RULE_communicationEmote = 61, 
		RULE_speech = 62, RULE_markedWord = 63, RULE_oRefInd = 64, RULE_eRefInd = 65, 
		RULE_indexedWord = 66, RULE_word = 67, RULE_punctuation = 68, RULE_integer = 69, 
		RULE_aimedDirection = 70;
	public static final String[] ruleNames = {
		"command", "direction", "tell", "say", "shout", "get", "getRoom", "getContainer", 
		"put", "drop", "give", "look", "eat", "drink", "lookAt", "lookIn", "lookWorn", 
		"fill", "spill", "empty", "switchHands", "hurl", "craft", "emote", "speak", 
		"exits", "open", "openDoor", "openContainer", "close", "closeDoor", "closeContainer", 
		"lock", "lockDoor", "lockContainer", "unlock", "unlockDoor", "unlockContainer", 
		"sets", "merge", "split", "hit", "flee", "stop", "wear", "remove", "status", 
		"skills", "set", "help", "inventory", "document", "score", "junk", "quit", 
		"adminActions", "a_lit", "a_mudStats", "a_coir", "a_shutdown", "bracketedEmote", 
		"communicationEmote", "speech", "markedWord", "oRefInd", "eRefInd", "indexedWord", 
		"word", "punctuation", "integer", "aimedDirection"
	};

	@Override
	public String getGrammarFileName() { return "CommandLineGrammar.g4"; }

	@Override
	public String[] getTokenNames() { return tokenNames; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }


	  	
	  private CommandInfo ci;
		
	  private boolean stringEmptyAndNotNull(String s) {
	    return s != null && !s.matches("[' ' | '\t']+") && !s.equals("");
	  }


	public CommandLineGrammarParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class CommandContext extends ParserRuleContext {
		public CommandInfo commandInfo;
		public PutContext put() {
			return getRuleContext(PutContext.class,0);
		}
		public EmoteContext emote() {
			return getRuleContext(EmoteContext.class,0);
		}
		public OpenContext open() {
			return getRuleContext(OpenContext.class,0);
		}
		public DropContext drop() {
			return getRuleContext(DropContext.class,0);
		}
		public SpeakContext speak() {
			return getRuleContext(SpeakContext.class,0);
		}
		public EatContext eat() {
			return getRuleContext(EatContext.class,0);
		}
		public ExitsContext exits() {
			return getRuleContext(ExitsContext.class,0);
		}
		public CloseContext close() {
			return getRuleContext(CloseContext.class,0);
		}
		public EmptyContext empty() {
			return getRuleContext(EmptyContext.class,0);
		}
		public FillContext fill() {
			return getRuleContext(FillContext.class,0);
		}
		public HelpContext help() {
			return getRuleContext(HelpContext.class,0);
		}
		public SkillsContext skills() {
			return getRuleContext(SkillsContext.class,0);
		}
		public SayContext say() {
			return getRuleContext(SayContext.class,0);
		}
		public SetsContext sets() {
			return getRuleContext(SetsContext.class,0);
		}
		public HurlContext hurl() {
			return getRuleContext(HurlContext.class,0);
		}
		public FleeContext flee() {
			return getRuleContext(FleeContext.class,0);
		}
		public GiveContext give() {
			return getRuleContext(GiveContext.class,0);
		}
		public DirectionContext direction() {
			return getRuleContext(DirectionContext.class,0);
		}
		public TellContext tell() {
			return getRuleContext(TellContext.class,0);
		}
		public DocumentContext document() {
			return getRuleContext(DocumentContext.class,0);
		}
		public HitContext hit() {
			return getRuleContext(HitContext.class,0);
		}
		public StatusContext status() {
			return getRuleContext(StatusContext.class,0);
		}
		public WearContext wear() {
			return getRuleContext(WearContext.class,0);
		}
		public JunkContext junk() {
			return getRuleContext(JunkContext.class,0);
		}
		public GetContext get() {
			return getRuleContext(GetContext.class,0);
		}
		public StopContext stop() {
			return getRuleContext(StopContext.class,0);
		}
		public LookContext look() {
			return getRuleContext(LookContext.class,0);
		}
		public SwitchHandsContext switchHands() {
			return getRuleContext(SwitchHandsContext.class,0);
		}
		public QuitContext quit() {
			return getRuleContext(QuitContext.class,0);
		}
		public DrinkContext drink() {
			return getRuleContext(DrinkContext.class,0);
		}
		public AdminActionsContext adminActions() {
			return getRuleContext(AdminActionsContext.class,0);
		}
		public InventoryContext inventory() {
			return getRuleContext(InventoryContext.class,0);
		}
		public UnlockContext unlock() {
			return getRuleContext(UnlockContext.class,0);
		}
		public SpillContext spill() {
			return getRuleContext(SpillContext.class,0);
		}
		public RemoveContext remove() {
			return getRuleContext(RemoveContext.class,0);
		}
		public LockContext lock() {
			return getRuleContext(LockContext.class,0);
		}
		public ScoreContext score() {
			return getRuleContext(ScoreContext.class,0);
		}
		public ShoutContext shout() {
			return getRuleContext(ShoutContext.class,0);
		}
		public SetContext set() {
			return getRuleContext(SetContext.class,0);
		}
		public CraftContext craft() {
			return getRuleContext(CraftContext.class,0);
		}
		public CommandContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_command; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterCommand(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitCommand(this);
		}
	}

	public final CommandContext command() throws RecognitionException {
		CommandContext _localctx = new CommandContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_command);
		try {
			setState(183);
			switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(143); say();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(144); tell();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(145); shout();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(146); direction();
				}
				break;

			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(147); get();
				}
				break;

			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(148); craft();
				}
				break;

			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(149); put();
				}
				break;

			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(150); drop();
				}
				break;

			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(151); give();
				}
				break;

			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(152); look();
				}
				break;

			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(153); eat();
				}
				break;

			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(154); drink();
				}
				break;

			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(155); hurl();
				}
				break;

			case 15:
				enterOuterAlt(_localctx, 15);
				{
				setState(156); emote();
				}
				break;

			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(157); speak();
				}
				break;

			case 17:
				enterOuterAlt(_localctx, 17);
				{
				setState(158); exits();
				}
				break;

			case 18:
				enterOuterAlt(_localctx, 18);
				{
				setState(159); inventory();
				}
				break;

			case 19:
				enterOuterAlt(_localctx, 19);
				{
				setState(160); open();
				}
				break;

			case 20:
				enterOuterAlt(_localctx, 20);
				{
				setState(161); close();
				}
				break;

			case 21:
				enterOuterAlt(_localctx, 21);
				{
				setState(162); lock();
				}
				break;

			case 22:
				enterOuterAlt(_localctx, 22);
				{
				setState(163); unlock();
				}
				break;

			case 23:
				enterOuterAlt(_localctx, 23);
				{
				setState(164); spill();
				}
				break;

			case 24:
				enterOuterAlt(_localctx, 24);
				{
				setState(165); fill();
				}
				break;

			case 25:
				enterOuterAlt(_localctx, 25);
				{
				setState(166); empty();
				}
				break;

			case 26:
				enterOuterAlt(_localctx, 26);
				{
				setState(167); wear();
				}
				break;

			case 27:
				enterOuterAlt(_localctx, 27);
				{
				setState(168); remove();
				}
				break;

			case 28:
				enterOuterAlt(_localctx, 28);
				{
				setState(169); status();
				}
				break;

			case 29:
				enterOuterAlt(_localctx, 29);
				{
				setState(170); skills();
				}
				break;

			case 30:
				enterOuterAlt(_localctx, 30);
				{
				setState(171); set();
				}
				break;

			case 31:
				enterOuterAlt(_localctx, 31);
				{
				setState(172); switchHands();
				}
				break;

			case 32:
				enterOuterAlt(_localctx, 32);
				{
				setState(173); sets();
				}
				break;

			case 33:
				enterOuterAlt(_localctx, 33);
				{
				setState(174); document();
				}
				break;

			case 34:
				enterOuterAlt(_localctx, 34);
				{
				setState(175); hit();
				}
				break;

			case 35:
				enterOuterAlt(_localctx, 35);
				{
				setState(176); flee();
				}
				break;

			case 36:
				enterOuterAlt(_localctx, 36);
				{
				setState(177); stop();
				}
				break;

			case 37:
				enterOuterAlt(_localctx, 37);
				{
				setState(178); junk();
				}
				break;

			case 38:
				enterOuterAlt(_localctx, 38);
				{
				setState(179); score();
				}
				break;

			case 39:
				enterOuterAlt(_localctx, 39);
				{
				setState(180); quit();
				}
				break;

			case 40:
				enterOuterAlt(_localctx, 40);
				{
				setState(181); help();
				}
				break;

			case 41:
				enterOuterAlt(_localctx, 41);
				{
				setState(182); adminActions();
				}
				break;
			}

				 { ((CommandContext)_localctx).commandInfo =  ci; }

		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DirectionContext extends ParserRuleContext {
		public BracketedEmoteContext oe;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode GO_EAST() { return getToken(CommandLineGrammarParser.GO_EAST, 0); }
		public TerminalNode GO_NORTH() { return getToken(CommandLineGrammarParser.GO_NORTH, 0); }
		public TerminalNode GO_SOUTH() { return getToken(CommandLineGrammarParser.GO_SOUTH, 0); }
		public TerminalNode GO_WEST() { return getToken(CommandLineGrammarParser.GO_WEST, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode GO_UP() { return getToken(CommandLineGrammarParser.GO_UP, 0); }
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public TerminalNode GO_DOWN() { return getToken(CommandLineGrammarParser.GO_DOWN, 0); }
		public DirectionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_direction; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterDirection(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitDirection(this);
		}
	}

	public final DirectionContext direction() throws RecognitionException {
		DirectionContext _localctx = new DirectionContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_direction);

			ci = new GoInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(186);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(185); match(WS);
				}
			}

			setState(200);
			switch (_input.LA(1)) {
			case GO_NORTH:
				{
				setState(188); match(GO_NORTH);

						((GoInfo) ci).setDirection( Direction.NORTH );
						
					
				}
				break;
			case GO_SOUTH:
				{
				setState(190); match(GO_SOUTH);

						((GoInfo) ci).setDirection( Direction.SOUTH );
					
				}
				break;
			case GO_WEST:
				{
				setState(192); match(GO_WEST);

						((GoInfo) ci).setDirection( Direction.WEST );
					
				}
				break;
			case GO_EAST:
				{
				setState(194); match(GO_EAST);

						((GoInfo) ci).setDirection( Direction.EAST );
					
				}
				break;
			case GO_UP:
				{
				setState(196); match(GO_UP);

						((GoInfo) ci).setDirection( Direction.UP );
					
				}
				break;
			case GO_DOWN:
				{
				setState(198); match(GO_DOWN);

						((GoInfo) ci).setDirection( Direction.DOWN );
					
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(203);
			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
			case 1:
				{
				setState(202); match(WS);
				}
				break;
			}
			setState(206);
			_la = _input.LA(1);
			if (_la==OPEN_B) {
				{
				setState(205); ((DirectionContext)_localctx).oe = bracketedEmote();
				}
			}

			setState(209);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(208); match(WS);
				}
			}


					if ( (((DirectionContext)_localctx).oe!=null?_input.getText(((DirectionContext)_localctx).oe.start,((DirectionContext)_localctx).oe.stop):null) != null ) {
						ci.setEmote( ((DirectionContext)_localctx).oe.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TellContext extends ParserRuleContext {
		public IndexedWordContext whom;
		public CommunicationEmoteContext oe;
		public SpeechContext s;
		public SpeechContext speech() {
			return getRuleContext(SpeechContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public CommunicationEmoteContext communicationEmote() {
			return getRuleContext(CommunicationEmoteContext.class,0);
		}
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public TerminalNode TELL() { return getToken(CommandLineGrammarParser.TELL, 0); }
		public TellContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tell; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterTell(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitTell(this);
		}
	}

	public final TellContext tell() throws RecognitionException {
		TellContext _localctx = new TellContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_tell);

			ci = new CommunicationInfo( CommandType.TELL );
			StringBuilder sb = new StringBuilder("");

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(214);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(213); match(WS);
				}
			}

			setState(216); match(TELL);
			setState(217); match(WS);
			setState(218); ((TellContext)_localctx).whom = indexedWord();
			setState(219); ((TellContext)_localctx).oe = communicationEmote();
			setState(220); ((TellContext)_localctx).s = speech();
			setState(222);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(221); match(WS);
				}
			}


					((CommunicationInfo) ci).setWhom( ((TellContext)_localctx).whom.iw );
					sb.append(((TellContext)_localctx).oe.s); // this appends only WS
					
					if ( stringEmptyAndNotNull( (((TellContext)_localctx).s!=null?_input.getText(((TellContext)_localctx).s.start,((TellContext)_localctx).s.stop):null) ) ) {
						sb.append( (((TellContext)_localctx).s!=null?_input.getText(((TellContext)_localctx).s.start,((TellContext)_localctx).s.stop):null) );
					};
					((CommunicationInfo) ci).setSpeech( sb.toString() );
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SayContext extends ParserRuleContext {
		public CommunicationEmoteContext oe;
		public SpeechContext s;
		public TerminalNode SAY() { return getToken(CommandLineGrammarParser.SAY, 0); }
		public SpeechContext speech() {
			return getRuleContext(SpeechContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public CommunicationEmoteContext communicationEmote() {
			return getRuleContext(CommunicationEmoteContext.class,0);
		}
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public SayContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_say; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterSay(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitSay(this);
		}
	}

	public final SayContext say() throws RecognitionException {
		SayContext _localctx = new SayContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_say);

			ci = new CommunicationInfo( CommandType.SAY );
			StringBuilder sb = new StringBuilder("");

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(227);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(226); match(WS);
				}
			}

			setState(229); match(SAY);
			setState(230); ((SayContext)_localctx).oe = communicationEmote();
			setState(231); ((SayContext)_localctx).s = speech();
			setState(233);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(232); match(WS);
				}
			}


					sb.append( ((SayContext)_localctx).oe.s ); // this appends only WS
					if ( stringEmptyAndNotNull( (((SayContext)_localctx).s!=null?_input.getText(((SayContext)_localctx).s.start,((SayContext)_localctx).s.stop):null) ) ) {
						sb.append( (((SayContext)_localctx).s!=null?_input.getText(((SayContext)_localctx).s.start,((SayContext)_localctx).s.stop):null) );
					}
					((CommunicationInfo) ci).setSpeech( sb.toString() );
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ShoutContext extends ParserRuleContext {
		public CommunicationEmoteContext oe;
		public SpeechContext s;
		public SpeechContext speech() {
			return getRuleContext(SpeechContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public CommunicationEmoteContext communicationEmote() {
			return getRuleContext(CommunicationEmoteContext.class,0);
		}
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode SHOUT() { return getToken(CommandLineGrammarParser.SHOUT, 0); }
		public ShoutContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_shout; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterShout(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitShout(this);
		}
	}

	public final ShoutContext shout() throws RecognitionException {
		ShoutContext _localctx = new ShoutContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_shout);

			ci = new CommunicationInfo( CommandType.SHOUT );
			StringBuilder sb = new StringBuilder("");

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(238);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(237); match(WS);
				}
			}

			setState(240); match(SHOUT);
			setState(241); ((ShoutContext)_localctx).oe = communicationEmote();
			setState(242); ((ShoutContext)_localctx).s = speech();
			setState(244);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(243); match(WS);
				}
			}


					sb.append( ((ShoutContext)_localctx).oe.s ); // this appends only WS
					if ( stringEmptyAndNotNull( (((ShoutContext)_localctx).s!=null?_input.getText(((ShoutContext)_localctx).s.start,((ShoutContext)_localctx).s.stop):null) ) ) {
						sb.append( (((ShoutContext)_localctx).s!=null?_input.getText(((ShoutContext)_localctx).s.start,((ShoutContext)_localctx).s.stop):null) );
					}
					((CommunicationInfo) ci).setSpeech( sb.toString() );
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GetContext extends ParserRuleContext {
		public GetContainerContext getContainer() {
			return getRuleContext(GetContainerContext.class,0);
		}
		public GetRoomContext getRoom() {
			return getRuleContext(GetRoomContext.class,0);
		}
		public GetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_get; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterGet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitGet(this);
		}
	}

	public final GetContext get() throws RecognitionException {
		GetContext _localctx = new GetContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_get);
		try {
			setState(250);
			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(248); getRoom();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(249); getContainer();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GetRoomContext extends ParserRuleContext {
		public IndexedWordContext what;
		public BracketedEmoteContext be;
		public TerminalNode GET() { return getToken(CommandLineGrammarParser.GET, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public GetRoomContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_getRoom; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterGetRoom(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitGetRoom(this);
		}
	}

	public final GetRoomContext getRoom() throws RecognitionException {
		GetRoomContext _localctx = new GetRoomContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_getRoom);

			ci = new ItemTransferInfo( CommandType.GET_ROOM );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(253);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(252); match(WS);
				}
			}

			setState(255); match(GET);
			setState(256); match(WS);
			setState(257); ((GetRoomContext)_localctx).what = indexedWord();
			setState(262);
			switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
			case 1:
				{
				setState(259);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(258); match(WS);
					}
				}

				setState(261); ((GetRoomContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(265);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(264); match(WS);
				}
			}


					((ItemTransferInfo) ci).setWhat( ((GetRoomContext)_localctx).what.iw );
					if ((((GetRoomContext)_localctx).be!=null?_input.getText(((GetRoomContext)_localctx).be.start,((GetRoomContext)_localctx).be.stop):null) != null) {
						ci.setEmote( ((GetRoomContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GetContainerContext extends ParserRuleContext {
		public IndexedWordContext what;
		public IndexedWordContext from;
		public Token dot;
		public BracketedEmoteContext be;
		public TerminalNode GET() { return getToken(CommandLineGrammarParser.GET, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord(int i) {
			return getRuleContext(IndexedWordContext.class,i);
		}
		public List<IndexedWordContext> indexedWord() {
			return getRuleContexts(IndexedWordContext.class);
		}
		public GetContainerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_getContainer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterGetContainer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitGetContainer(this);
		}
	}

	public final GetContainerContext getContainer() throws RecognitionException {
		GetContainerContext _localctx = new GetContainerContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_getContainer);

			ci = new ItemTransferInfo( CommandType.GET_CONTAINER );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(270);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(269); match(WS);
				}
			}

			setState(272); match(GET);
			setState(273); match(WS);
			setState(274); ((GetContainerContext)_localctx).what = indexedWord();
			setState(275); match(WS);
			setState(276); ((GetContainerContext)_localctx).from = indexedWord();
			setState(281);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				{
				setState(278);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(277); match(WS);
					}
				}

				setState(280); ((GetContainerContext)_localctx).dot = match(DOT);
				}
				break;
			}
			setState(287);
			switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
			case 1:
				{
				setState(284);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(283); match(WS);
					}
				}

				setState(286); ((GetContainerContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(290);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(289); match(WS);
				}
			}


					((ItemTransferInfo)ci).setWhat( ((GetContainerContext)_localctx).what.iw );
					((ItemTransferInfo)ci).setFrom( ((GetContainerContext)_localctx).from.iw );
					((ItemTransferInfo)ci).setGround( (((GetContainerContext)_localctx).dot!=null?((GetContainerContext)_localctx).dot.getText():null) != null );
					if ( (((GetContainerContext)_localctx).be!=null?_input.getText(((GetContainerContext)_localctx).be.start,((GetContainerContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((GetContainerContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PutContext extends ParserRuleContext {
		public IndexedWordContext what;
		public IndexedWordContext in;
		public Token dot;
		public BracketedEmoteContext be;
		public TerminalNode PUT() { return getToken(CommandLineGrammarParser.PUT, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord(int i) {
			return getRuleContext(IndexedWordContext.class,i);
		}
		public List<IndexedWordContext> indexedWord() {
			return getRuleContexts(IndexedWordContext.class);
		}
		public PutContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_put; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterPut(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitPut(this);
		}
	}

	public final PutContext put() throws RecognitionException {
		PutContext _localctx = new PutContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_put);

			ci = new ItemTransferInfo( CommandType.PUT );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(295);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(294); match(WS);
				}
			}

			setState(297); match(PUT);
			setState(298); match(WS);
			setState(299); ((PutContext)_localctx).what = indexedWord();
			setState(300); match(WS);
			setState(301); ((PutContext)_localctx).in = indexedWord();
			setState(303);
			switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
			case 1:
				{
				setState(302); match(WS);
				}
				break;
			}
			setState(309);
			_la = _input.LA(1);
			if (_la==DOT) {
				{
				setState(305); ((PutContext)_localctx).dot = match(DOT);
				setState(307);
				switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
				case 1:
					{
					setState(306); match(WS);
					}
					break;
				}
				}
			}

			setState(312);
			_la = _input.LA(1);
			if (_la==OPEN_B) {
				{
				setState(311); ((PutContext)_localctx).be = bracketedEmote();
				}
			}

			setState(315);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(314); match(WS);
				}
			}


					((ItemTransferInfo)ci).setWhat( ((PutContext)_localctx).what.iw );
					((ItemTransferInfo)ci).setIn( ((PutContext)_localctx).in.iw );
					((ItemTransferInfo)ci).setGround( (((PutContext)_localctx).dot!=null?((PutContext)_localctx).dot.getText():null) != null );
					if ( (((PutContext)_localctx).be!=null?_input.getText(((PutContext)_localctx).be.start,((PutContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((PutContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DropContext extends ParserRuleContext {
		public IndexedWordContext what;
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public TerminalNode DROP() { return getToken(CommandLineGrammarParser.DROP, 0); }
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public DropContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_drop; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterDrop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitDrop(this);
		}
	}

	public final DropContext drop() throws RecognitionException {
		DropContext _localctx = new DropContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_drop);

			ci = new ItemTransferInfo( CommandType.DROP );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(320);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(319); match(WS);
				}
			}

			setState(322); match(DROP);
			setState(323); match(WS);
			setState(324); ((DropContext)_localctx).what = indexedWord();
			setState(329);
			switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
			case 1:
				{
				setState(326);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(325); match(WS);
					}
				}

				setState(328); ((DropContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(332);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(331); match(WS);
				}
			}


					((ItemTransferInfo)ci).setWhat( ((DropContext)_localctx).what.iw );
					if ( (((DropContext)_localctx).be!=null?_input.getText(((DropContext)_localctx).be.start,((DropContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((DropContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GiveContext extends ParserRuleContext {
		public IndexedWordContext what;
		public IndexedWordContext whom;
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode GIVE() { return getToken(CommandLineGrammarParser.GIVE, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord(int i) {
			return getRuleContext(IndexedWordContext.class,i);
		}
		public List<IndexedWordContext> indexedWord() {
			return getRuleContexts(IndexedWordContext.class);
		}
		public GiveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_give; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterGive(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitGive(this);
		}
	}

	public final GiveContext give() throws RecognitionException {
		GiveContext _localctx = new GiveContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_give);

			ci = new ItemTransferInfo( CommandType.GIVE );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(337);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(336); match(WS);
				}
			}

			setState(339); match(GIVE);
			setState(340); match(WS);
			setState(341); ((GiveContext)_localctx).what = indexedWord();
			setState(342); match(WS);
			setState(343); ((GiveContext)_localctx).whom = indexedWord();
			setState(348);
			switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
			case 1:
				{
				setState(345);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(344); match(WS);
					}
				}

				setState(347); ((GiveContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(351);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(350); match(WS);
				}
			}


					((ItemTransferInfo) ci).setWhat( ((GiveContext)_localctx).what.iw );
					((ItemTransferInfo) ci).setWhom( ((GiveContext)_localctx).whom.iw );
					if ( (((GiveContext)_localctx).be!=null?_input.getText(((GiveContext)_localctx).be.start,((GiveContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((GiveContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LookContext extends ParserRuleContext {
		public LookWornContext lookWorn() {
			return getRuleContext(LookWornContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public LookInContext lookIn() {
			return getRuleContext(LookInContext.class,0);
		}
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public LookAtContext lookAt() {
			return getRuleContext(LookAtContext.class,0);
		}
		public TerminalNode LOOK() { return getToken(CommandLineGrammarParser.LOOK, 0); }
		public LookContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_look; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterLook(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitLook(this);
		}
	}

	public final LookContext look() throws RecognitionException {
		LookContext _localctx = new LookContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_look);
		int _la;
		try {
			setState(366);
			switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(356);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(355); match(WS);
					}
				}

				setState(358); match(LOOK);
				setState(360);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(359); match(WS);
					}
				}


						ci = new LookInfo( CommandType.LOOK );
					
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(363); lookAt();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(364); lookIn();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(365); lookWorn();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EatContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public IntegerContext i;
		public Token d;
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public IntegerContext integer() {
			return getRuleContext(IntegerContext.class,0);
		}
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public TerminalNode EAT() { return getToken(CommandLineGrammarParser.EAT, 0); }
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public EatContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_eat; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterEat(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitEat(this);
		}
	}

	public final EatContext eat() throws RecognitionException {
		EatContext _localctx = new EatContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_eat);

			ci = new FoodInfo( ConsumptionType.EAT );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(369);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(368); match(WS);
				}
			}

			setState(371); match(EAT);
			setState(372); match(WS);
			setState(373); ((EatContext)_localctx).iw = indexedWord();
			setState(376);
			switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
			case 1:
				{
				setState(374); match(WS);
				setState(375); ((EatContext)_localctx).i = integer();
				}
				break;
			}
			setState(382);
			switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
			case 1:
				{
				setState(379);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(378); match(WS);
					}
				}

				setState(381); ((EatContext)_localctx).d = match(DOT);
				}
				break;
			}
			setState(388);
			switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
			case 1:
				{
				setState(385);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(384); match(WS);
					}
				}

				setState(387); ((EatContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(391);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(390); match(WS);
				}
			}


					((FoodInfo) ci).setWhat( ((EatContext)_localctx).iw.iw );
					if ((((EatContext)_localctx).d!=null?((EatContext)_localctx).d.getText():null) != null) {
						((FoodInfo) ci).setGround( true );
					}
					if ( (((EatContext)_localctx).i!=null?_input.getText(((EatContext)_localctx).i.start,((EatContext)_localctx).i.stop):null) != null ) {
						((FoodInfo) ci).setAmount( ((EatContext)_localctx).i.s );
					}
					if ( (((EatContext)_localctx).be!=null?_input.getText(((EatContext)_localctx).be.start,((EatContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((EatContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DrinkContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public IntegerContext i;
		public Token d;
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public IntegerContext integer() {
			return getRuleContext(IntegerContext.class,0);
		}
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public TerminalNode DRINK() { return getToken(CommandLineGrammarParser.DRINK, 0); }
		public DrinkContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_drink; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterDrink(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitDrink(this);
		}
	}

	public final DrinkContext drink() throws RecognitionException {
		DrinkContext _localctx = new DrinkContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_drink);

			ci = new FoodInfo( ConsumptionType.DRINK );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(396);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(395); match(WS);
				}
			}

			setState(398); match(DRINK);
			setState(399); match(WS);
			setState(400); ((DrinkContext)_localctx).iw = indexedWord();
			setState(403);
			switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
			case 1:
				{
				setState(401); match(WS);
				setState(402); ((DrinkContext)_localctx).i = integer();
				}
				break;
			}
			setState(409);
			switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
			case 1:
				{
				setState(406);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(405); match(WS);
					}
				}

				setState(408); ((DrinkContext)_localctx).d = match(DOT);
				}
				break;
			}
			setState(415);
			switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
			case 1:
				{
				setState(412);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(411); match(WS);
					}
				}

				setState(414); ((DrinkContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(418);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(417); match(WS);
				}
			}


					((FoodInfo) ci).setWhat( ((DrinkContext)_localctx).iw.iw );
					if ( (((DrinkContext)_localctx).d!=null?((DrinkContext)_localctx).d.getText():null) != null ) {
						((FoodInfo) ci).setGround( true );
					}
					if ( (((DrinkContext)_localctx).i!=null?_input.getText(((DrinkContext)_localctx).i.start,((DrinkContext)_localctx).i.stop):null) != null ) {
						((FoodInfo) ci).setAmount( ((DrinkContext)_localctx).i.s );
					}
					if ( (((DrinkContext)_localctx).be!=null?_input.getText(((DrinkContext)_localctx).be.start,((DrinkContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((DrinkContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LookAtContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public Token dot;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public TerminalNode LOOK() { return getToken(CommandLineGrammarParser.LOOK, 0); }
		public LookAtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lookAt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterLookAt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitLookAt(this);
		}
	}

	public final LookAtContext lookAt() throws RecognitionException {
		LookAtContext _localctx = new LookAtContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_lookAt);

			ci = new LookInfo( CommandType.LOOK_AT );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(423);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(422); match(WS);
				}
			}

			setState(425); match(LOOK);
			setState(426); match(WS);
			setState(427); ((LookAtContext)_localctx).iw = indexedWord();
			setState(432);
			switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
			case 1:
				{
				setState(429);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(428); match(WS);
					}
				}

				setState(431); ((LookAtContext)_localctx).dot = match(DOT);
				}
				break;
			}
			setState(435);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(434); match(WS);
				}
			}


						((LookInfo) ci).setWhat( ((LookAtContext)_localctx).iw.iw );
						((LookInfo) ci).setGround( (((LookAtContext)_localctx).dot!=null?((LookAtContext)_localctx).dot.getText():null) != null );
					
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LookInContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public Token dot;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public List<TerminalNode> DOT() { return getTokens(CommandLineGrammarParser.DOT); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public TerminalNode DOT(int i) {
			return getToken(CommandLineGrammarParser.DOT, i);
		}
		public TerminalNode LOOK() { return getToken(CommandLineGrammarParser.LOOK, 0); }
		public LookInContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lookIn; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterLookIn(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitLookIn(this);
		}
	}

	public final LookInContext lookIn() throws RecognitionException {
		LookInContext _localctx = new LookInContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_lookIn);

			ci = new LookInfo( CommandType.LOOK_IN );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(440);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(439); match(WS);
				}
			}

			setState(442); match(LOOK);
			setState(444);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(443); match(WS);
				}
			}

			setState(446); match(DOT);
			setState(448);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(447); match(WS);
				}
			}

			setState(450); ((LookInContext)_localctx).iw = indexedWord();
			setState(455);
			switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
			case 1:
				{
				setState(452);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(451); match(WS);
					}
				}

				setState(454); ((LookInContext)_localctx).dot = match(DOT);
				}
				break;
			}
			setState(458);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(457); match(WS);
				}
			}


						((LookInfo) ci).setWhat( ((LookInContext)_localctx).iw.iw );
						((LookInfo) ci).setGround( (((LookInContext)_localctx).dot!=null?((LookInContext)_localctx).dot.getText():null) != null );
					
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LookWornContext extends ParserRuleContext {
		public IndexedWordContext iw1;
		public IndexedWordContext iw2;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public IndexedWordContext indexedWord(int i) {
			return getRuleContext(IndexedWordContext.class,i);
		}
		public List<IndexedWordContext> indexedWord() {
			return getRuleContexts(IndexedWordContext.class);
		}
		public TerminalNode LOOK() { return getToken(CommandLineGrammarParser.LOOK, 0); }
		public LookWornContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lookWorn; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterLookWorn(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitLookWorn(this);
		}
	}

	public final LookWornContext lookWorn() throws RecognitionException {
		LookWornContext _localctx = new LookWornContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_lookWorn);

			ci = new LookInfo( CommandType.LOOK_WORN );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(463);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(462); match(WS);
				}
			}

			setState(465); match(LOOK);
			setState(466); match(WS);
			setState(467); ((LookWornContext)_localctx).iw1 = indexedWord();
			setState(468); match(WS);
			setState(469); ((LookWornContext)_localctx).iw2 = indexedWord();
			setState(471);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(470); match(WS);
				}
			}


						((LookInfo) ci).setWhat( ((LookWornContext)_localctx).iw1.iw );
						((LookInfo) ci).setWho( ((LookWornContext)_localctx).iw2.iw );
					
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FillContext extends ParserRuleContext {
		public IndexedWordContext iw1;
		public IndexedWordContext iw2;
		public Token ground;
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public TerminalNode FILL() { return getToken(CommandLineGrammarParser.FILL, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord(int i) {
			return getRuleContext(IndexedWordContext.class,i);
		}
		public List<IndexedWordContext> indexedWord() {
			return getRuleContexts(IndexedWordContext.class);
		}
		public FillContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fill; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterFill(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitFill(this);
		}
	}

	public final FillContext fill() throws RecognitionException {
		FillContext _localctx = new FillContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_fill);

			ci = new FillInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(476);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(475); match(WS);
				}
			}

			setState(478); match(FILL);
			setState(479); match(WS);
			setState(480); ((FillContext)_localctx).iw1 = indexedWord();
			setState(481); match(WS);
			setState(482); ((FillContext)_localctx).iw2 = indexedWord();
			setState(485);
			switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
			case 1:
				{
				setState(483); match(WS);
				setState(484); ((FillContext)_localctx).ground = match(DOT);
				}
				break;
			}
			setState(491);
			switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
			case 1:
				{
				setState(488);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(487); match(WS);
					}
				}

				setState(490); ((FillContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(494);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(493); match(WS);
				}
			}


					((FillInfo) ci).setToBeFilled( ((FillContext)_localctx).iw1.iw );
					((FillInfo) ci).setToFillFrom( ((FillContext)_localctx).iw2.iw );
					if ( (((FillContext)_localctx).ground!=null?((FillContext)_localctx).ground.getText():null) != null ) {
						((FillInfo) ci).setGround (true);
					}
					if ( (((FillContext)_localctx).be!=null?_input.getText(((FillContext)_localctx).be.start,((FillContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((FillContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SpillContext extends ParserRuleContext {
		public IndexedWordContext iw1;
		public IntegerContext i;
		public IndexedWordContext iw2;
		public Token dot;
		public BracketedEmoteContext be;
		public TerminalNode SPILL() { return getToken(CommandLineGrammarParser.SPILL, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public IntegerContext integer() {
			return getRuleContext(IntegerContext.class,0);
		}
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord(int i) {
			return getRuleContext(IndexedWordContext.class,i);
		}
		public List<IndexedWordContext> indexedWord() {
			return getRuleContexts(IndexedWordContext.class);
		}
		public SpillContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_spill; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterSpill(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitSpill(this);
		}
	}

	public final SpillContext spill() throws RecognitionException {
		SpillContext _localctx = new SpillContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_spill);

			ci = new SpillInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(499);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(498); match(WS);
				}
			}

			setState(501); match(SPILL);
			setState(502); match(WS);
			setState(503); ((SpillContext)_localctx).iw1 = indexedWord();
			setState(506);
			switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
			case 1:
				{
				setState(504); match(WS);
				setState(505); ((SpillContext)_localctx).i = integer();
				}
				break;
			}
			setState(516);
			switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
			case 1:
				{
				setState(508); match(WS);
				setState(509); ((SpillContext)_localctx).iw2 = indexedWord();
				setState(514);
				switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
				case 1:
					{
					setState(511);
					_la = _input.LA(1);
					if (_la==WS) {
						{
						setState(510); match(WS);
						}
					}

					setState(513); ((SpillContext)_localctx).dot = match(DOT);
					}
					break;
				}
				}
				break;
			}
			setState(522);
			switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
			case 1:
				{
				setState(519);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(518); match(WS);
					}
				}

				setState(521); ((SpillContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(525);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(524); match(WS);
				}
			}


						((SpillInfo) ci).setToBeSpilled( ((SpillContext)_localctx).iw1.iw );
						if ( (((SpillContext)_localctx).iw2!=null?_input.getText(((SpillContext)_localctx).iw2.start,((SpillContext)_localctx).iw2.stop):null) != null ) {
							((SpillInfo) ci).setSpillInto( ((SpillContext)_localctx).iw2.iw );
						}
						if ( (((SpillContext)_localctx).i!=null?_input.getText(((SpillContext)_localctx).i.start,((SpillContext)_localctx).i.stop):null) != null ) {
							((SpillInfo) ci).setAmount( ((SpillContext)_localctx).i.s );
						}
						if ((((SpillContext)_localctx).dot!=null?((SpillContext)_localctx).dot.getText():null) != null) {
							((SpillInfo) ci).setGround( true );
						}
						if ( (((SpillContext)_localctx).be!=null?_input.getText(((SpillContext)_localctx).be.start,((SpillContext)_localctx).be.stop):null) != null ) {
							ci.setEmote( ((SpillContext)_localctx).be.s );
						}
					
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EmptyContext extends ParserRuleContext {
		public IndexedWordContext iw1;
		public BracketedEmoteContext be;
		public TerminalNode EMPTY() { return getToken(CommandLineGrammarParser.EMPTY, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public EmptyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_empty; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterEmpty(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitEmpty(this);
		}
	}

	public final EmptyContext empty() throws RecognitionException {
		EmptyContext _localctx = new EmptyContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_empty);

			ci = new EmptyInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(530);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(529); match(WS);
				}
			}

			setState(532); match(EMPTY);
			setState(533); match(WS);
			setState(534); ((EmptyContext)_localctx).iw1 = indexedWord();
			setState(539);
			switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
			case 1:
				{
				setState(536);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(535); match(WS);
					}
				}

				setState(538); ((EmptyContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(542);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(541); match(WS);
				}
			}


					((EmptyInfo) ci).setEmptyFrom( ((EmptyContext)_localctx).iw1.iw );
					if ( (((EmptyContext)_localctx).be!=null?_input.getText(((EmptyContext)_localctx).be.start,((EmptyContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((EmptyContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SwitchHandsContext extends ParserRuleContext {
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode SWITCH() { return getToken(CommandLineGrammarParser.SWITCH, 0); }
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public SwitchHandsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_switchHands; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterSwitchHands(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitSwitchHands(this);
		}
	}

	public final SwitchHandsContext switchHands() throws RecognitionException {
		SwitchHandsContext _localctx = new SwitchHandsContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_switchHands);

			ci = new SwitchInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(547);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(546); match(WS);
				}
			}

			setState(549); match(SWITCH);
			setState(554);
			switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
			case 1:
				{
				setState(551);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(550); match(WS);
					}
				}

				setState(553); ((SwitchHandsContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(557);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(556); match(WS);
				}
			}


					if ( (((SwitchHandsContext)_localctx).be!=null?_input.getText(((SwitchHandsContext)_localctx).be.start,((SwitchHandsContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((SwitchHandsContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class HurlContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public AimedDirectionContext td;
		public BracketedEmoteContext be;
		public AimedDirectionContext aimedDirection() {
			return getRuleContext(AimedDirectionContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public TerminalNode THROW() { return getToken(CommandLineGrammarParser.THROW, 0); }
		public HurlContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_hurl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterHurl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitHurl(this);
		}
	}

	public final HurlContext hurl() throws RecognitionException {
		HurlContext _localctx = new HurlContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_hurl);

			ci = new ThrowInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(562);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(561); match(WS);
				}
			}

			setState(564); match(THROW);
			setState(565); match(WS);
			setState(566); ((HurlContext)_localctx).iw = indexedWord();
			setState(567); match(WS);
			setState(568); ((HurlContext)_localctx).td = aimedDirection();
			setState(573);
			switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
			case 1:
				{
				setState(570);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(569); match(WS);
					}
				}

				setState(572); ((HurlContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(576);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(575); match(WS);
				}
			}


					((ThrowInfo) ci).setWhat( ((HurlContext)_localctx).iw.iw );
					((ThrowInfo) ci).setDirection( ((HurlContext)_localctx).td.d );
					if ( (((HurlContext)_localctx).be!=null?_input.getText(((HurlContext)_localctx).be.start,((HurlContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((HurlContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CraftContext extends ParserRuleContext {
		public SpeechContext s;
		public SpeechContext speech() {
			return getRuleContext(SpeechContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode CRAFT() { return getToken(CommandLineGrammarParser.CRAFT, 0); }
		public CraftContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_craft; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterCraft(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitCraft(this);
		}
	}

	public final CraftContext craft() throws RecognitionException {
		CraftContext _localctx = new CraftContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_craft);

			ci = new CraftInfo();	

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(581);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(580); match(WS);
				}
			}

			setState(583); match(CRAFT);
			setState(585);
			switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
			case 1:
				{
				setState(584); match(WS);
				}
				break;
			}
			setState(587); ((CraftContext)_localctx).s = speech();
			setState(589);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(588); match(WS);
				}
			}


					((CraftInfo) ci).setCommand( (((CraftContext)_localctx).s!=null?_input.getText(((CraftContext)_localctx).s.start,((CraftContext)_localctx).s.stop):null) );
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EmoteContext extends ParserRuleContext {
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public EmoteContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_emote; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterEmote(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitEmote(this);
		}
	}

	public final EmoteContext emote() throws RecognitionException {
		EmoteContext _localctx = new EmoteContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_emote);

			ci = new EmoteInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(594);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(593); match(WS);
				}
			}

			setState(596); ((EmoteContext)_localctx).be = bracketedEmote();
			setState(598);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(597); match(WS);
				}
			}


					if ( (((EmoteContext)_localctx).be!=null?_input.getText(((EmoteContext)_localctx).be.start,((EmoteContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((EmoteContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SpeakContext extends ParserRuleContext {
		public SpeechContext w;
		public SpeechContext speech() {
			return getRuleContext(SpeechContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode SPEAK() { return getToken(CommandLineGrammarParser.SPEAK, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public SpeakContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_speak; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterSpeak(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitSpeak(this);
		}
	}

	public final SpeakContext speak() throws RecognitionException {
		SpeakContext _localctx = new SpeakContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_speak);

			ci = new SpeakInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(603);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(602); match(WS);
				}
			}

			setState(605); match(SPEAK);
			setState(608);
			switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
			case 1:
				{
				setState(606); match(WS);
				setState(607); ((SpeakContext)_localctx).w = speech();
				}
				break;
			}
			setState(611);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(610); match(WS);
				}
			}


					((SpeakInfo) ci).setLanguage( (((SpeakContext)_localctx).w!=null?_input.getText(((SpeakContext)_localctx).w.start,((SpeakContext)_localctx).w.stop):null) );
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExitsContext extends ParserRuleContext {
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode EXITS() { return getToken(CommandLineGrammarParser.EXITS, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public ExitsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exits; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterExits(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitExits(this);
		}
	}

	public final ExitsContext exits() throws RecognitionException {
		ExitsContext _localctx = new ExitsContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_exits);

			ci = new ExitsInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(616);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(615); match(WS);
				}
			}

			setState(618); match(EXITS);
			setState(620);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(619); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OpenContext extends ParserRuleContext {
		public OpenDoorContext openDoor() {
			return getRuleContext(OpenDoorContext.class,0);
		}
		public OpenContainerContext openContainer() {
			return getRuleContext(OpenContainerContext.class,0);
		}
		public OpenContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_open; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterOpen(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitOpen(this);
		}
	}

	public final OpenContext open() throws RecognitionException {
		OpenContext _localctx = new OpenContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_open);
		try {
			setState(624);
			switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(622); openDoor();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(623); openContainer();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OpenDoorContext extends ParserRuleContext {
		public AimedDirectionContext ad;
		public BracketedEmoteContext be;
		public AimedDirectionContext aimedDirection() {
			return getRuleContext(AimedDirectionContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode OPEN() { return getToken(CommandLineGrammarParser.OPEN, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public OpenDoorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_openDoor; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterOpenDoor(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitOpenDoor(this);
		}
	}

	public final OpenDoorContext openDoor() throws RecognitionException {
		OpenDoorContext _localctx = new OpenDoorContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_openDoor);

			ci = new ManipulationDoorInfo( ManipulationType.OPEN );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(627);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(626); match(WS);
				}
			}

			setState(629); match(OPEN);
			setState(630); match(WS);
			setState(631); ((OpenDoorContext)_localctx).ad = aimedDirection();
			setState(636);
			switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
			case 1:
				{
				setState(633);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(632); match(WS);
					}
				}

				setState(635); ((OpenDoorContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(639);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(638); match(WS);
				}
			}


					((ManipulationDoorInfo) ci).setDirection( ((OpenDoorContext)_localctx).ad.d );
					if ((((OpenDoorContext)_localctx).be!=null?_input.getText(((OpenDoorContext)_localctx).be.start,((OpenDoorContext)_localctx).be.stop):null) != null) {
						ci.setEmote( ((OpenDoorContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OpenContainerContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public Token dot;
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public TerminalNode OPEN() { return getToken(CommandLineGrammarParser.OPEN, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public OpenContainerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_openContainer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterOpenContainer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitOpenContainer(this);
		}
	}

	public final OpenContainerContext openContainer() throws RecognitionException {
		OpenContainerContext _localctx = new OpenContainerContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_openContainer);

			ci = new ManipulationContainerInfo( ManipulationType.OPEN );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(644);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(643); match(WS);
				}
			}

			setState(646); match(OPEN);
			setState(647); match(WS);
			setState(648); ((OpenContainerContext)_localctx).iw = indexedWord();
			setState(653);
			switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) {
			case 1:
				{
				setState(650);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(649); match(WS);
					}
				}

				setState(652); ((OpenContainerContext)_localctx).dot = match(DOT);
				}
				break;
			}
			setState(659);
			switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
			case 1:
				{
				setState(656);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(655); match(WS);
					}
				}

				setState(658); ((OpenContainerContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(662);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(661); match(WS);
				}
			}


					((ManipulationContainerInfo) ci).setWhat( ((OpenContainerContext)_localctx).iw.iw );
					((ManipulationContainerInfo) ci).setGround( (((OpenContainerContext)_localctx).dot!=null?((OpenContainerContext)_localctx).dot.getText():null) != null );
					if ( (((OpenContainerContext)_localctx).be!=null?_input.getText(((OpenContainerContext)_localctx).be.start,((OpenContainerContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((OpenContainerContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CloseContext extends ParserRuleContext {
		public CloseDoorContext closeDoor() {
			return getRuleContext(CloseDoorContext.class,0);
		}
		public CloseContainerContext closeContainer() {
			return getRuleContext(CloseContainerContext.class,0);
		}
		public CloseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_close; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterClose(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitClose(this);
		}
	}

	public final CloseContext close() throws RecognitionException {
		CloseContext _localctx = new CloseContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_close);
		try {
			setState(668);
			switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(666); closeDoor();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(667); closeContainer();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CloseDoorContext extends ParserRuleContext {
		public AimedDirectionContext ad;
		public BracketedEmoteContext be;
		public AimedDirectionContext aimedDirection() {
			return getRuleContext(AimedDirectionContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode CLOSE() { return getToken(CommandLineGrammarParser.CLOSE, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public CloseDoorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_closeDoor; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterCloseDoor(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitCloseDoor(this);
		}
	}

	public final CloseDoorContext closeDoor() throws RecognitionException {
		CloseDoorContext _localctx = new CloseDoorContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_closeDoor);

			ci = new ManipulationDoorInfo( ManipulationType.CLOSE );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(671);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(670); match(WS);
				}
			}

			setState(673); match(CLOSE);
			setState(674); match(WS);
			setState(675); ((CloseDoorContext)_localctx).ad = aimedDirection();
			setState(680);
			switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
			case 1:
				{
				setState(677);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(676); match(WS);
					}
				}

				setState(679); ((CloseDoorContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(683);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(682); match(WS);
				}
			}


					((ManipulationDoorInfo) ci).setDirection( ((CloseDoorContext)_localctx).ad.d );
					if ( (((CloseDoorContext)_localctx).be!=null?_input.getText(((CloseDoorContext)_localctx).be.start,((CloseDoorContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((CloseDoorContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CloseContainerContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public Token dot;
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public TerminalNode CLOSE() { return getToken(CommandLineGrammarParser.CLOSE, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public CloseContainerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_closeContainer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterCloseContainer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitCloseContainer(this);
		}
	}

	public final CloseContainerContext closeContainer() throws RecognitionException {
		CloseContainerContext _localctx = new CloseContainerContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_closeContainer);

			ci = new ManipulationContainerInfo( ManipulationType.CLOSE );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(688);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(687); match(WS);
				}
			}

			setState(690); match(CLOSE);
			setState(691); match(WS);
			setState(692); ((CloseContainerContext)_localctx).iw = indexedWord();
			setState(697);
			switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
			case 1:
				{
				setState(694);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(693); match(WS);
					}
				}

				setState(696); ((CloseContainerContext)_localctx).dot = match(DOT);
				}
				break;
			}
			setState(703);
			switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
			case 1:
				{
				setState(700);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(699); match(WS);
					}
				}

				setState(702); ((CloseContainerContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(706);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(705); match(WS);
				}
			}


					((ManipulationContainerInfo) ci).setWhat( ((CloseContainerContext)_localctx).iw.iw );
					((ManipulationContainerInfo) ci).setGround( (((CloseContainerContext)_localctx).dot!=null?((CloseContainerContext)_localctx).dot.getText():null) != null );
					if ( (((CloseContainerContext)_localctx).be!=null?_input.getText(((CloseContainerContext)_localctx).be.start,((CloseContainerContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((CloseContainerContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LockContext extends ParserRuleContext {
		public LockDoorContext lockDoor() {
			return getRuleContext(LockDoorContext.class,0);
		}
		public LockContainerContext lockContainer() {
			return getRuleContext(LockContainerContext.class,0);
		}
		public LockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lock; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterLock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitLock(this);
		}
	}

	public final LockContext lock() throws RecognitionException {
		LockContext _localctx = new LockContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_lock);
		try {
			setState(712);
			switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(710); lockDoor();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(711); lockContainer();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LockDoorContext extends ParserRuleContext {
		public AimedDirectionContext ad;
		public BracketedEmoteContext be;
		public AimedDirectionContext aimedDirection() {
			return getRuleContext(AimedDirectionContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode LOCK() { return getToken(CommandLineGrammarParser.LOCK, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public LockDoorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lockDoor; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterLockDoor(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitLockDoor(this);
		}
	}

	public final LockDoorContext lockDoor() throws RecognitionException {
		LockDoorContext _localctx = new LockDoorContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_lockDoor);

			ci = new ManipulationDoorInfo( ManipulationType.LOCK );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(715);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(714); match(WS);
				}
			}

			setState(717); match(LOCK);
			setState(718); match(WS);
			setState(719); ((LockDoorContext)_localctx).ad = aimedDirection();
			setState(724);
			switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
			case 1:
				{
				setState(721);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(720); match(WS);
					}
				}

				setState(723); ((LockDoorContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(727);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(726); match(WS);
				}
			}


					((ManipulationDoorInfo) ci).setDirection( ((LockDoorContext)_localctx).ad.d );
					if ( (((LockDoorContext)_localctx).be!=null?_input.getText(((LockDoorContext)_localctx).be.start,((LockDoorContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((LockDoorContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LockContainerContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public Token dot;
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public TerminalNode LOCK() { return getToken(CommandLineGrammarParser.LOCK, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public LockContainerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lockContainer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterLockContainer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitLockContainer(this);
		}
	}

	public final LockContainerContext lockContainer() throws RecognitionException {
		LockContainerContext _localctx = new LockContainerContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_lockContainer);

			ci = new ManipulationContainerInfo( ManipulationType.LOCK );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(732);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(731); match(WS);
				}
			}

			setState(734); match(LOCK);
			setState(735); match(WS);
			setState(736); ((LockContainerContext)_localctx).iw = indexedWord();
			setState(741);
			switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
			case 1:
				{
				setState(738);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(737); match(WS);
					}
				}

				setState(740); ((LockContainerContext)_localctx).dot = match(DOT);
				}
				break;
			}
			setState(747);
			switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
			case 1:
				{
				setState(744);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(743); match(WS);
					}
				}

				setState(746); ((LockContainerContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(750);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(749); match(WS);
				}
			}


					((ManipulationContainerInfo) ci).setWhat( ((LockContainerContext)_localctx).iw.iw );
					((ManipulationContainerInfo) ci).setGround( (((LockContainerContext)_localctx).dot!=null?((LockContainerContext)_localctx).dot.getText():null) != null );
					if ( (((LockContainerContext)_localctx).be!=null?_input.getText(((LockContainerContext)_localctx).be.start,((LockContainerContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((LockContainerContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UnlockContext extends ParserRuleContext {
		public UnlockContainerContext unlockContainer() {
			return getRuleContext(UnlockContainerContext.class,0);
		}
		public UnlockDoorContext unlockDoor() {
			return getRuleContext(UnlockDoorContext.class,0);
		}
		public UnlockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unlock; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterUnlock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitUnlock(this);
		}
	}

	public final UnlockContext unlock() throws RecognitionException {
		UnlockContext _localctx = new UnlockContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_unlock);
		try {
			setState(756);
			switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(754); unlockDoor();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(755); unlockContainer();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UnlockDoorContext extends ParserRuleContext {
		public AimedDirectionContext ad;
		public BracketedEmoteContext be;
		public AimedDirectionContext aimedDirection() {
			return getRuleContext(AimedDirectionContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode UNLOCK() { return getToken(CommandLineGrammarParser.UNLOCK, 0); }
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public UnlockDoorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unlockDoor; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterUnlockDoor(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitUnlockDoor(this);
		}
	}

	public final UnlockDoorContext unlockDoor() throws RecognitionException {
		UnlockDoorContext _localctx = new UnlockDoorContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_unlockDoor);

			ci = new ManipulationDoorInfo( ManipulationType.UNLOCK );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(759);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(758); match(WS);
				}
			}

			setState(761); match(UNLOCK);
			setState(762); match(WS);
			setState(763); ((UnlockDoorContext)_localctx).ad = aimedDirection();
			setState(768);
			switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
			case 1:
				{
				setState(765);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(764); match(WS);
					}
				}

				setState(767); ((UnlockDoorContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(771);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(770); match(WS);
				}
			}


					((ManipulationDoorInfo) ci).setDirection( ((UnlockDoorContext)_localctx).ad.d );
					if ( (((UnlockDoorContext)_localctx).be!=null?_input.getText(((UnlockDoorContext)_localctx).be.start,((UnlockDoorContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((UnlockDoorContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UnlockContainerContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public Token dot;
		public BracketedEmoteContext be;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode UNLOCK() { return getToken(CommandLineGrammarParser.UNLOCK, 0); }
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public UnlockContainerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unlockContainer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterUnlockContainer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitUnlockContainer(this);
		}
	}

	public final UnlockContainerContext unlockContainer() throws RecognitionException {
		UnlockContainerContext _localctx = new UnlockContainerContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_unlockContainer);

			ci = new ManipulationContainerInfo( ManipulationType.UNLOCK );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(776);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(775); match(WS);
				}
			}

			setState(778); match(UNLOCK);
			setState(779); match(WS);
			setState(780); ((UnlockContainerContext)_localctx).iw = indexedWord();
			setState(785);
			switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
			case 1:
				{
				setState(782);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(781); match(WS);
					}
				}

				setState(784); ((UnlockContainerContext)_localctx).dot = match(DOT);
				}
				break;
			}
			setState(791);
			switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
			case 1:
				{
				setState(788);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(787); match(WS);
					}
				}

				setState(790); ((UnlockContainerContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(794);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(793); match(WS);
				}
			}


					((ManipulationContainerInfo) ci).setWhat( ((UnlockContainerContext)_localctx).iw.iw );
					((ManipulationContainerInfo) ci).setGround( (((UnlockContainerContext)_localctx).dot!=null?((UnlockContainerContext)_localctx).dot.getText():null) != null );
					if ( (((UnlockContainerContext)_localctx).be!=null?_input.getText(((UnlockContainerContext)_localctx).be.start,((UnlockContainerContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((UnlockContainerContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetsContext extends ParserRuleContext {
		public SplitContext split() {
			return getRuleContext(SplitContext.class,0);
		}
		public MergeContext merge() {
			return getRuleContext(MergeContext.class,0);
		}
		public SetsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sets; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterSets(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitSets(this);
		}
	}

	public final SetsContext sets() throws RecognitionException {
		SetsContext _localctx = new SetsContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_sets);
		try {
			setState(800);
			switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(798); merge();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(799); split();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MergeContext extends ParserRuleContext {
		public IndexedWordContext iw1;
		public Token dot1;
		public IndexedWordContext iw2;
		public Token dot2;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public List<TerminalNode> DOT() { return getTokens(CommandLineGrammarParser.DOT); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public IndexedWordContext indexedWord(int i) {
			return getRuleContext(IndexedWordContext.class,i);
		}
		public TerminalNode DOT(int i) {
			return getToken(CommandLineGrammarParser.DOT, i);
		}
		public List<IndexedWordContext> indexedWord() {
			return getRuleContexts(IndexedWordContext.class);
		}
		public TerminalNode MERGE() { return getToken(CommandLineGrammarParser.MERGE, 0); }
		public MergeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_merge; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterMerge(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitMerge(this);
		}
	}

	public final MergeContext merge() throws RecognitionException {
		MergeContext _localctx = new MergeContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_merge);

			ci = new SetsInfo( SetsOperation.MERGE );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(803);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(802); match(WS);
				}
			}

			setState(805); match(MERGE);
			setState(806); match(WS);
			setState(807); ((MergeContext)_localctx).iw1 = indexedWord();
			setState(816);
			switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
			case 1:
				{
				setState(809);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(808); match(WS);
					}
				}

				setState(811); ((MergeContext)_localctx).dot1 = match(DOT);
				setState(813);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(812); match(WS);
					}
				}

				}
				break;

			case 2:
				{
				setState(815); match(WS);
				}
				break;
			}
			setState(818); ((MergeContext)_localctx).iw2 = indexedWord();
			setState(823);
			switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
			case 1:
				{
				setState(820);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(819); match(WS);
					}
				}

				setState(822); ((MergeContext)_localctx).dot2 = match(DOT);
				}
				break;
			}
			setState(826);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(825); match(WS);
				}
			}


					((SetsInfo) ci).setSet1( ((MergeContext)_localctx).iw1.iw );
					((SetsInfo) ci).setSet2( ((MergeContext)_localctx).iw2.iw );
					((SetsInfo) ci).setGround1( (((MergeContext)_localctx).dot1!=null?((MergeContext)_localctx).dot1.getText():null) != null );
					((SetsInfo) ci).setGround2( (((MergeContext)_localctx).dot2!=null?((MergeContext)_localctx).dot2.getText():null) != null );
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SplitContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public Token dot;
		public IntegerContext n;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public IntegerContext integer() {
			return getRuleContext(IntegerContext.class,0);
		}
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode SPLIT() { return getToken(CommandLineGrammarParser.SPLIT, 0); }
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public SplitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_split; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterSplit(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitSplit(this);
		}
	}

	public final SplitContext split() throws RecognitionException {
		SplitContext _localctx = new SplitContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_split);

			ci = new SetsInfo( SetsOperation.SPLIT );

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(831);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(830); match(WS);
				}
			}

			setState(833); match(SPLIT);
			setState(834); match(WS);
			setState(835); ((SplitContext)_localctx).iw = indexedWord();
			setState(844);
			switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
			case 1:
				{
				setState(837);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(836); match(WS);
					}
				}

				setState(839); ((SplitContext)_localctx).dot = match(DOT);
				setState(841);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(840); match(WS);
					}
				}

				}
				break;

			case 2:
				{
				setState(843); match(WS);
				}
				break;
			}
			setState(846); ((SplitContext)_localctx).n = integer();
			setState(848);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(847); match(WS);
				}
			}


					((SetsInfo) ci).setSet1( ((SplitContext)_localctx).iw.iw );
					((SetsInfo) ci).setGround1( (((SplitContext)_localctx).dot!=null?((SplitContext)_localctx).dot.getText():null) != null );
					((SetsInfo) ci).setAmount( ((SplitContext)_localctx).n.s );
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class HitContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public TerminalNode HIT() { return getToken(CommandLineGrammarParser.HIT, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public HitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_hit; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterHit(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitHit(this);
		}
	}

	public final HitContext hit() throws RecognitionException {
		HitContext _localctx = new HitContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_hit);

			ci = new HitInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(853);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(852); match(WS);
				}
			}

			setState(855); match(HIT);
			setState(856); match(WS);
			setState(857); ((HitContext)_localctx).iw = indexedWord();
			setState(859);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(858); match(WS);
				}
			}


					((HitInfo) ci).setWhom( ((HitContext)_localctx).iw.iw);
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FleeContext extends ParserRuleContext {
		public TerminalNode OFF() { return getToken(CommandLineGrammarParser.OFF, 0); }
		public TerminalNode GO_EAST() { return getToken(CommandLineGrammarParser.GO_EAST, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode FLEE() { return getToken(CommandLineGrammarParser.FLEE, 0); }
		public TerminalNode GO_NORTH() { return getToken(CommandLineGrammarParser.GO_NORTH, 0); }
		public TerminalNode GO_SOUTH() { return getToken(CommandLineGrammarParser.GO_SOUTH, 0); }
		public TerminalNode GO_WEST() { return getToken(CommandLineGrammarParser.GO_WEST, 0); }
		public TerminalNode GO_UP() { return getToken(CommandLineGrammarParser.GO_UP, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode GO_DOWN() { return getToken(CommandLineGrammarParser.GO_DOWN, 0); }
		public FleeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_flee; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterFlee(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitFlee(this);
		}
	}

	public final FleeContext flee() throws RecognitionException {
		FleeContext _localctx = new FleeContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_flee);

			ci = new FleeInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(864);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(863); match(WS);
				}
			}

			setState(866); match(FLEE);
			setState(884);
			switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) {
			case 1:
				{
				setState(867); match(WS);
				setState(882);
				switch (_input.LA(1)) {
				case GO_NORTH:
					{
					setState(868); match(GO_NORTH);

							((FleeInfo) ci).setDirection( Direction.NORTH );
						
					}
					break;
				case GO_EAST:
					{
					setState(870); match(GO_EAST);

							((FleeInfo) ci).setDirection( Direction.EAST );
						
					}
					break;
				case GO_SOUTH:
					{
					setState(872); match(GO_SOUTH);

							((FleeInfo) ci).setDirection( Direction.SOUTH );
						
					}
					break;
				case GO_WEST:
					{
					setState(874); match(GO_WEST);

							((FleeInfo) ci).setDirection( Direction.WEST );
						
					}
					break;
				case GO_UP:
					{
					setState(876); match(GO_UP);

							((FleeInfo) ci).setDirection( Direction.UP );
						
					}
					break;
				case GO_DOWN:
					{
					setState(878); match(GO_DOWN);

							((FleeInfo) ci).setDirection( Direction.DOWN );
						
					}
					break;
				case OFF:
					{
					setState(880); match(OFF);

							((FleeInfo) ci).setStopFleeing( true );
						
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			}
			setState(887);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(886); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StopContext extends ParserRuleContext {
		public TerminalNode STOP() { return getToken(CommandLineGrammarParser.STOP, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public StopContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stop; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterStop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitStop(this);
		}
	}

	public final StopContext stop() throws RecognitionException {
		StopContext _localctx = new StopContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_stop);

			ci = new StopInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(890);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(889); match(WS);
				}
			}

			setState(892); match(STOP);
			setState(894);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(893); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WearContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public WordContext w;
		public BracketedEmoteContext be;
		public WordContext word() {
			return getRuleContext(WordContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public TerminalNode WEAR() { return getToken(CommandLineGrammarParser.WEAR, 0); }
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public WearContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_wear; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterWear(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitWear(this);
		}
	}

	public final WearContext wear() throws RecognitionException {
		WearContext _localctx = new WearContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_wear);

			ci = new WearInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(897);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(896); match(WS);
				}
			}

			setState(899); match(WEAR);
			setState(900); match(WS);
			setState(901); ((WearContext)_localctx).iw = indexedWord();
			setState(904);
			switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
			case 1:
				{
				setState(902); match(WS);
				setState(903); ((WearContext)_localctx).w = word();
				}
				break;
			}
			setState(910);
			switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
			case 1:
				{
				setState(907);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(906); match(WS);
					}
				}

				setState(909); ((WearContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(913);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(912); match(WS);
				}
			}


					((WearInfo) ci).setWhat( ((WearContext)_localctx).iw.iw );
					if ((((WearContext)_localctx).w!=null?_input.getText(((WearContext)_localctx).w.start,((WearContext)_localctx).w.stop):null) != null) {
						((WearInfo) ci).setWearLoc( (((WearContext)_localctx).w!=null?_input.getText(((WearContext)_localctx).w.start,((WearContext)_localctx).w.stop):null) );
					}
					if ( (((WearContext)_localctx).be!=null?_input.getText(((WearContext)_localctx).be.start,((WearContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((WearContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RemoveContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public BracketedEmoteContext be;
		public TerminalNode REMOVE() { return getToken(CommandLineGrammarParser.REMOVE, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public RemoveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_remove; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterRemove(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitRemove(this);
		}
	}

	public final RemoveContext remove() throws RecognitionException {
		RemoveContext _localctx = new RemoveContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_remove);

			ci = new RemoveInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(918);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(917); match(WS);
				}
			}

			setState(920); match(REMOVE);
			setState(921); match(WS);
			setState(922); ((RemoveContext)_localctx).iw = indexedWord();
			setState(927);
			switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
			case 1:
				{
				setState(924);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(923); match(WS);
					}
				}

				setState(926); ((RemoveContext)_localctx).be = bracketedEmote();
				}
				break;
			}
			setState(930);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(929); match(WS);
				}
			}


					((RemoveInfo) ci).setWhat( ((RemoveContext)_localctx).iw.iw );
					if ( (((RemoveContext)_localctx).be!=null?_input.getText(((RemoveContext)_localctx).be.start,((RemoveContext)_localctx).be.stop):null) != null ) {
						ci.setEmote( ((RemoveContext)_localctx).be.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StatusContext extends ParserRuleContext {
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode STATUS() { return getToken(CommandLineGrammarParser.STATUS, 0); }
		public StatusContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_status; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterStatus(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitStatus(this);
		}
	}

	public final StatusContext status() throws RecognitionException {
		StatusContext _localctx = new StatusContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_status);

			ci = new StatusInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(935);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(934); match(WS);
				}
			}

			setState(937); match(STATUS);
			setState(939);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(938); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SkillsContext extends ParserRuleContext {
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode SKILLS() { return getToken(CommandLineGrammarParser.SKILLS, 0); }
		public SkillsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_skills; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterSkills(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitSkills(this);
		}
	}

	public final SkillsContext skills() throws RecognitionException {
		SkillsContext _localctx = new SkillsContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_skills);

			ci = new SkillsInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(942);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(941); match(WS);
				}
			}

			setState(944); match(SKILLS);
			setState(946);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(945); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetContext extends ParserRuleContext {
		public TerminalNode SET() { return getToken(CommandLineGrammarParser.SET, 0); }
		public TerminalNode OFF() { return getToken(CommandLineGrammarParser.OFF, 0); }
		public TerminalNode ON() { return getToken(CommandLineGrammarParser.ON, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode ACCEPTGIVE() { return getToken(CommandLineGrammarParser.ACCEPTGIVE, 0); }
		public TerminalNode PACIFIST() { return getToken(CommandLineGrammarParser.PACIFIST, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public SetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_set; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterSet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitSet(this);
		}
	}

	public final SetContext set() throws RecognitionException {
		SetContext _localctx = new SetContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_set);

			ci = new SetInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(949);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(948); match(WS);
				}
			}

			setState(951); match(SET);
			setState(952); match(WS);
			setState(957);
			switch (_input.LA(1)) {
			case PACIFIST:
				{
				setState(953); match(PACIFIST);

						((SetInfo) ci).setSetType( SetType.PACIFIST);
					
				}
				break;
			case ACCEPTGIVE:
				{
				setState(955); match(ACCEPTGIVE);

						((SetInfo) ci).setSetType( SetType.ACCEPTGIVE);
					
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(959); match(WS);
			setState(964);
			switch (_input.LA(1)) {
			case ON:
				{
				setState(960); match(ON);

						((SetInfo) ci).setOn( true );
					
				}
				break;
			case OFF:
				{
				setState(962); match(OFF);

						((SetInfo) ci).setOn( false );	
					
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(967);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(966); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class HelpContext extends ParserRuleContext {
		public SpeechContext s;
		public TerminalNode HELP() { return getToken(CommandLineGrammarParser.HELP, 0); }
		public SpeechContext speech() {
			return getRuleContext(SpeechContext.class,0);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public HelpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_help; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterHelp(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitHelp(this);
		}
	}

	public final HelpContext help() throws RecognitionException {
		HelpContext _localctx = new HelpContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_help);

			ci = new HelpInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(970);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(969); match(WS);
				}
			}

			setState(972); match(HELP);
			setState(973); match(WS);
			setState(974); ((HelpContext)_localctx).s = speech();
			setState(976);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(975); match(WS);
				}
			}


					((HelpInfo) ci).setHelpOn( (((HelpContext)_localctx).s!=null?_input.getText(((HelpContext)_localctx).s.start,((HelpContext)_localctx).s.stop):null) );
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InventoryContext extends ParserRuleContext {
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode INVENTORY() { return getToken(CommandLineGrammarParser.INVENTORY, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public InventoryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inventory; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterInventory(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitInventory(this);
		}
	}

	public final InventoryContext inventory() throws RecognitionException {
		InventoryContext _localctx = new InventoryContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_inventory);

			ci = new InvInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(981);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(980); match(WS);
				}
			}

			setState(983); match(INVENTORY);
			setState(985);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(984); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DocumentContext extends ParserRuleContext {
		public IntegerContext i;
		public TerminalNode DOCUMENT() { return getToken(CommandLineGrammarParser.DOCUMENT, 0); }
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public IntegerContext integer() {
			return getRuleContext(IntegerContext.class,0);
		}
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public DocumentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_document; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterDocument(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitDocument(this);
		}
	}

	public final DocumentContext document() throws RecognitionException {
		DocumentContext _localctx = new DocumentContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_document);

			ci = new DocumentInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(988);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(987); match(WS);
				}
			}

			setState(990); match(DOCUMENT);
			setState(991); match(WS);
			setState(992); ((DocumentContext)_localctx).i = integer();
			setState(994);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(993); match(WS);
				}
			}


					((DocumentInfo) ci).setDocID( ((DocumentContext)_localctx).i.s );
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ScoreContext extends ParserRuleContext {
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode SCORE() { return getToken(CommandLineGrammarParser.SCORE, 0); }
		public ScoreContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_score; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterScore(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitScore(this);
		}
	}

	public final ScoreContext score() throws RecognitionException {
		ScoreContext _localctx = new ScoreContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_score);

			ci = new ScoreInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(999);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(998); match(WS);
				}
			}

			setState(1001); match(SCORE);
			setState(1003);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1002); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class JunkContext extends ParserRuleContext {
		public IndexedWordContext iw;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode JUNK() { return getToken(CommandLineGrammarParser.JUNK, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public JunkContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_junk; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterJunk(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitJunk(this);
		}
	}

	public final JunkContext junk() throws RecognitionException {
		JunkContext _localctx = new JunkContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_junk);

			ci = new JunkInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1006);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1005); match(WS);
				}
			}

			setState(1008); match(JUNK);
			setState(1009); match(WS);
			setState(1010); ((JunkContext)_localctx).iw = indexedWord();
			setState(1012);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1011); match(WS);
				}
			}


					((JunkInfo) ci).setWhat( ((JunkContext)_localctx).iw.iw );
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QuitContext extends ParserRuleContext {
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode QUIT() { return getToken(CommandLineGrammarParser.QUIT, 0); }
		public QuitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_quit; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterQuit(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitQuit(this);
		}
	}

	public final QuitContext quit() throws RecognitionException {
		QuitContext _localctx = new QuitContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_quit);

			ci = new QuitInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1017);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1016); match(WS);
				}
			}

			setState(1019); match(QUIT);
			setState(1021);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1020); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AdminActionsContext extends ParserRuleContext {
		public A_shutdownContext a_shutdown() {
			return getRuleContext(A_shutdownContext.class,0);
		}
		public A_coirContext a_coir() {
			return getRuleContext(A_coirContext.class,0);
		}
		public A_litContext a_lit() {
			return getRuleContext(A_litContext.class,0);
		}
		public TerminalNode ADMIN() { return getToken(CommandLineGrammarParser.ADMIN, 0); }
		public A_mudStatsContext a_mudStats() {
			return getRuleContext(A_mudStatsContext.class,0);
		}
		public AdminActionsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_adminActions; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterAdminActions(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitAdminActions(this);
		}
	}

	public final AdminActionsContext adminActions() throws RecognitionException {
		AdminActionsContext _localctx = new AdminActionsContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_adminActions);
		try {
			setState(1031);
			switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1023); match(ADMIN);
				setState(1024); a_shutdown();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1025); match(ADMIN);
				setState(1026); a_coir();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1027); match(ADMIN);
				setState(1028); a_mudStats();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1029); match(ADMIN);
				setState(1030); a_lit();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class A_litContext extends ParserRuleContext {
		public WordContext w;
		public List<WordContext> word() {
			return getRuleContexts(WordContext.class);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public WordContext word(int i) {
			return getRuleContext(WordContext.class,i);
		}
		public TerminalNode A_LISTITEMTEMPLATES() { return getToken(CommandLineGrammarParser.A_LISTITEMTEMPLATES, 0); }
		public A_litContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_a_lit; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterA_lit(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitA_lit(this);
		}
	}

	public final A_litContext a_lit() throws RecognitionException {
		A_litContext _localctx = new A_litContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_a_lit);

			ci = new ListItemTemplatesInfo();

		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1034);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1033); match(WS);
				}
			}

			setState(1036); match(A_LISTITEMTEMPLATES);
			setState(1043);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,197,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					{
					setState(1037); match(WS);
					setState(1038); ((A_litContext)_localctx).w = word();

							((ListItemTemplatesInfo) ci).getKeywords().add( (((A_litContext)_localctx).w!=null?_input.getText(((A_litContext)_localctx).w.start,((A_litContext)_localctx).w.stop):null) );	
						
					}
					} 
				}
				setState(1045);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,197,_ctx);
			}
			setState(1047);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1046); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class A_mudStatsContext extends ParserRuleContext {
		public WordContext w;
		public List<WordContext> word() {
			return getRuleContexts(WordContext.class);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode A_MUDSTATS() { return getToken(CommandLineGrammarParser.A_MUDSTATS, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public WordContext word(int i) {
			return getRuleContext(WordContext.class,i);
		}
		public A_mudStatsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_a_mudStats; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterA_mudStats(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitA_mudStats(this);
		}
	}

	public final A_mudStatsContext a_mudStats() throws RecognitionException {
		A_mudStatsContext _localctx = new A_mudStatsContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_a_mudStats);

			ci = new MudStatsInfo();

		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1050);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1049); match(WS);
				}
			}

			setState(1052); match(A_MUDSTATS);
			setState(1059);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,200,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					{
					setState(1053); match(WS);
					setState(1054); ((A_mudStatsContext)_localctx).w = word();

							((MudStatsInfo) ci).getSpecifics().add( (((A_mudStatsContext)_localctx).w!=null?_input.getText(((A_mudStatsContext)_localctx).w.start,((A_mudStatsContext)_localctx).w.stop):null) );	
						
					}
					} 
				}
				setState(1061);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,200,_ctx);
			}
			setState(1063);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1062); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class A_coirContext extends ParserRuleContext {
		public IntegerContext c;
		public IntegerContext n;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public IntegerContext integer(int i) {
			return getRuleContext(IntegerContext.class,i);
		}
		public List<IntegerContext> integer() {
			return getRuleContexts(IntegerContext.class);
		}
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public TerminalNode A_COIR() { return getToken(CommandLineGrammarParser.A_COIR, 0); }
		public A_coirContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_a_coir; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterA_coir(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitA_coir(this);
		}
	}

	public final A_coirContext a_coir() throws RecognitionException {
		A_coirContext _localctx = new A_coirContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_a_coir);

			ci = new COIRInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1066);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1065); match(WS);
				}
			}

			setState(1068); match(A_COIR);
			setState(1069); match(WS);
			setState(1070); ((A_coirContext)_localctx).c = integer();
			setState(1073);
			switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
			case 1:
				{
				setState(1071); match(WS);
				setState(1072); ((A_coirContext)_localctx).n = integer();
				}
				break;
			}
			setState(1076);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1075); match(WS);
				}
			}


					((COIRInfo) ci).setCode( ((A_coirContext)_localctx).c.s );
					if ( (((A_coirContext)_localctx).n!=null?_input.getText(((A_coirContext)_localctx).n.start,((A_coirContext)_localctx).n.stop):null) != null ) {
						((COIRInfo) ci).setAmount( ((A_coirContext)_localctx).n.s );
					}
				
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class A_shutdownContext extends ParserRuleContext {
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode A_SHUTDOWN() { return getToken(CommandLineGrammarParser.A_SHUTDOWN, 0); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public A_shutdownContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_a_shutdown; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterA_shutdown(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitA_shutdown(this);
		}
	}

	public final A_shutdownContext a_shutdown() throws RecognitionException {
		A_shutdownContext _localctx = new A_shutdownContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_a_shutdown);

			ci = new ShutdownInfo();

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1081);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1080); match(WS);
				}
			}

			setState(1083); match(A_SHUTDOWN);
			setState(1085);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(1084); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BracketedEmoteContext extends ParserRuleContext {
		public String s;
		public Token OPEN_B;
		public WordContext w;
		public IntegerContext i;
		public MarkedWordContext mw;
		public PunctuationContext p;
		public Token WS;
		public TerminalNode OPEN_B(int i) {
			return getToken(CommandLineGrammarParser.OPEN_B, i);
		}
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public PunctuationContext punctuation(int i) {
			return getRuleContext(PunctuationContext.class,i);
		}
		public List<TerminalNode> STAR() { return getTokens(CommandLineGrammarParser.STAR); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public List<TerminalNode> AT() { return getTokens(CommandLineGrammarParser.AT); }
		public TerminalNode CLOSE_B(int i) {
			return getToken(CommandLineGrammarParser.CLOSE_B, i);
		}
		public List<TerminalNode> CLOSE_B() { return getTokens(CommandLineGrammarParser.CLOSE_B); }
		public TerminalNode DOT(int i) {
			return getToken(CommandLineGrammarParser.DOT, i);
		}
		public TerminalNode AT(int i) {
			return getToken(CommandLineGrammarParser.AT, i);
		}
		public MarkedWordContext markedWord(int i) {
			return getRuleContext(MarkedWordContext.class,i);
		}
		public List<WordContext> word() {
			return getRuleContexts(WordContext.class);
		}
		public List<TerminalNode> TILDE() { return getTokens(CommandLineGrammarParser.TILDE); }
		public IntegerContext integer(int i) {
			return getRuleContext(IntegerContext.class,i);
		}
		public List<TerminalNode> OPEN_B() { return getTokens(CommandLineGrammarParser.OPEN_B); }
		public List<TerminalNode> DOT() { return getTokens(CommandLineGrammarParser.DOT); }
		public List<IntegerContext> integer() {
			return getRuleContexts(IntegerContext.class);
		}
		public TerminalNode TILDE(int i) {
			return getToken(CommandLineGrammarParser.TILDE, i);
		}
		public List<PunctuationContext> punctuation() {
			return getRuleContexts(PunctuationContext.class);
		}
		public TerminalNode STAR(int i) {
			return getToken(CommandLineGrammarParser.STAR, i);
		}
		public List<MarkedWordContext> markedWord() {
			return getRuleContexts(MarkedWordContext.class);
		}
		public WordContext word(int i) {
			return getRuleContext(WordContext.class,i);
		}
		public BracketedEmoteContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bracketedEmote; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterBracketedEmote(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitBracketedEmote(this);
		}
	}

	public final BracketedEmoteContext bracketedEmote() throws RecognitionException {
		BracketedEmoteContext _localctx = new BracketedEmoteContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_bracketedEmote);

			StringBuilder sb = new StringBuilder("");
			int openPos;
			int accum = 0;

		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1087); ((BracketedEmoteContext)_localctx).OPEN_B = match(OPEN_B);

				  	openPos = ((BracketedEmoteContext)_localctx).OPEN_B.getStartIndex();
				  
			setState(1117);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,208,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					setState(1115);
					switch ( getInterpreter().adaptivePredict(_input,207,_ctx) ) {
					case 1:
						{
						setState(1089); ((BracketedEmoteContext)_localctx).w = word();

									sb.append( (((BracketedEmoteContext)_localctx).w!=null?_input.getText(((BracketedEmoteContext)_localctx).w.start,((BracketedEmoteContext)_localctx).w.stop):null) );
								
						}
						break;

					case 2:
						{
						setState(1092); ((BracketedEmoteContext)_localctx).i = integer();

									sb.append( ((BracketedEmoteContext)_localctx).i.s );
								
						}
						break;

					case 3:
						{
						setState(1095); ((BracketedEmoteContext)_localctx).mw = markedWord();

							    	ci.getiWords().add( ((BracketedEmoteContext)_localctx).mw.iw );
							   		// --substract to the marked word's start position the OPEN position -2 - accum
									((BracketedEmoteContext)_localctx).mw.iw.setPos( ((BracketedEmoteContext)_localctx).mw.iw.getPos() - openPos - 2 - accum);
									accum += ((BracketedEmoteContext)_localctx).mw.iw.getWord().length() + ((BracketedEmoteContext)_localctx).mw.il;
							    
						}
						break;

					case 4:
						{
						setState(1098); ((BracketedEmoteContext)_localctx).p = punctuation();

									sb.append( ((BracketedEmoteContext)_localctx).p.s );
								
						}
						break;

					case 5:
						{
						setState(1101); match(DOT);

									sb.append( "." );
								
						}
						break;

					case 6:
						{
						setState(1103); ((BracketedEmoteContext)_localctx).WS = match(WS);

									sb.append( (((BracketedEmoteContext)_localctx).WS!=null?((BracketedEmoteContext)_localctx).WS.getText():null) );
								
						}
						break;

					case 7:
						{
						setState(1105); match(STAR);

									sb.append( "*" );
								
						}
						break;

					case 8:
						{
						setState(1107); match(TILDE);

									sb.append( "~" );
							  
						}
						break;

					case 9:
						{
						setState(1109); ((BracketedEmoteContext)_localctx).OPEN_B = match(OPEN_B);

									sb.append( "(" );
							  
						}
						break;

					case 10:
						{
						setState(1111); match(CLOSE_B);

									sb.append( ")" );
							  
						}
						break;

					case 11:
						{
						setState(1113); match(AT);

							  		sb.append( "@" );
							  
						}
						break;
					}
					} 
				}
				setState(1119);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,208,_ctx);
			}
			setState(1120); match(CLOSE_B);
			}

				((BracketedEmoteContext)_localctx).s =  sb.toString();

		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CommunicationEmoteContext extends ParserRuleContext {
		public String s;
		public Token prebefore;
		public BracketedEmoteContext b;
		public Token before;
		public List<TerminalNode> WS() { return getTokens(CommandLineGrammarParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CommandLineGrammarParser.WS, i);
		}
		public BracketedEmoteContext bracketedEmote() {
			return getRuleContext(BracketedEmoteContext.class,0);
		}
		public CommunicationEmoteContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_communicationEmote; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterCommunicationEmote(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitCommunicationEmote(this);
		}
	}

	public final CommunicationEmoteContext communicationEmote() throws RecognitionException {
		CommunicationEmoteContext _localctx = new CommunicationEmoteContext(_ctx, getState());
		enterRule(_localctx, 122, RULE_communicationEmote);

			StringBuilder sb = new StringBuilder("");

		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1123);
			switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) {
			case 1:
				{
				setState(1122); ((CommunicationEmoteContext)_localctx).prebefore = match(WS);
				}
				break;
			}
			setState(1132);
			switch ( getInterpreter().adaptivePredict(_input,212,_ctx) ) {
			case 1:
				{
				setState(1126);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(1125); match(WS);
					}
				}

				setState(1128); ((CommunicationEmoteContext)_localctx).b = bracketedEmote();
				setState(1130);
				switch ( getInterpreter().adaptivePredict(_input,211,_ctx) ) {
				case 1:
					{
					setState(1129); ((CommunicationEmoteContext)_localctx).before = match(WS);
					}
					break;
				}
				}
				break;
			}

					if ( (((CommunicationEmoteContext)_localctx).b!=null?_input.getText(((CommunicationEmoteContext)_localctx).b.start,((CommunicationEmoteContext)_localctx).b.stop):null) != null ) { // there's an emote
						if ( (((CommunicationEmoteContext)_localctx).before!=null?((CommunicationEmoteContext)_localctx).before.getText():null) != null && (((CommunicationEmoteContext)_localctx).before!=null?((CommunicationEmoteContext)_localctx).before.getText():null).length() > 1 ) {
							sb.append( (((CommunicationEmoteContext)_localctx).before!=null?((CommunicationEmoteContext)_localctx).before.getText():null).substring( 1, (((CommunicationEmoteContext)_localctx).before!=null?((CommunicationEmoteContext)_localctx).before.getText():null).length() ) );
						}
						ci.setEmote( ((CommunicationEmoteContext)_localctx).b.s );
					} else {
						if ( (((CommunicationEmoteContext)_localctx).prebefore!=null?((CommunicationEmoteContext)_localctx).prebefore.getText():null) != null && (((CommunicationEmoteContext)_localctx).prebefore!=null?((CommunicationEmoteContext)_localctx).prebefore.getText():null).length() > 1 ) { // no BEmote: use the first set of spaces
							sb.append( (((CommunicationEmoteContext)_localctx).prebefore!=null?((CommunicationEmoteContext)_localctx).prebefore.getText():null).substring( 1, (((CommunicationEmoteContext)_localctx).prebefore!=null?((CommunicationEmoteContext)_localctx).prebefore.getText():null).length() ) );
						}
					}
				
			}

				((CommunicationEmoteContext)_localctx).s =  sb.toString();

		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SpeechContext extends ParserRuleContext {
		public SpeechContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_speech; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterSpeech(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitSpeech(this);
		}
	}

	public final SpeechContext speech() throws RecognitionException {
		SpeechContext _localctx = new SpeechContext(_ctx, getState());
		enterRule(_localctx, 124, RULE_speech);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1139);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,213,_ctx);
			while ( _alt!=1 && _alt!=-1 ) {
				if ( _alt==1+1 ) {
					{
					{
					setState(1136);
					matchWildcard();
					}
					} 
				}
				setState(1141);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,213,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MarkedWordContext extends ParserRuleContext {
		public IndexedWord iw;
		public int il;
		public ORefIndContext o;
		public ERefIndContext e;
		public ERefIndContext eRefInd() {
			return getRuleContext(ERefIndContext.class,0);
		}
		public ORefIndContext oRefInd() {
			return getRuleContext(ORefIndContext.class,0);
		}
		public MarkedWordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_markedWord; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterMarkedWord(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitMarkedWord(this);
		}
	}

	public final MarkedWordContext markedWord() throws RecognitionException {
		MarkedWordContext _localctx = new MarkedWordContext(_ctx, getState());
		enterRule(_localctx, 126, RULE_markedWord);
		try {
			setState(1148);
			switch (_input.LA(1)) {
			case STAR:
				enterOuterAlt(_localctx, 1);
				{
				setState(1142); ((MarkedWordContext)_localctx).o = oRefInd();

							((MarkedWordContext)_localctx).iw =  ((MarkedWordContext)_localctx).o.oIW;
							((MarkedWordContext)_localctx).il =  ((MarkedWordContext)_localctx).o.il;
						
				}
				break;
			case TILDE:
				enterOuterAlt(_localctx, 2);
				{
				setState(1145); ((MarkedWordContext)_localctx).e = eRefInd();

							((MarkedWordContext)_localctx).iw =  ((MarkedWordContext)_localctx).e.eIW;
							((MarkedWordContext)_localctx).il =  ((MarkedWordContext)_localctx).e.il;
						
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ORefIndContext extends ParserRuleContext {
		public IndexedWord oIW;
		public int il;
		public IndexedWordContext iw;
		public TerminalNode STAR() { return getToken(CommandLineGrammarParser.STAR, 0); }
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public ORefIndContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_oRefInd; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterORefInd(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitORefInd(this);
		}
	}

	public final ORefIndContext oRefInd() throws RecognitionException {
		ORefIndContext _localctx = new ORefIndContext(_ctx, getState());
		enterRule(_localctx, 128, RULE_oRefInd);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1150); match(STAR);
			setState(1151); ((ORefIndContext)_localctx).iw = indexedWord();

						((ORefIndContext)_localctx).oIW =  ((ORefIndContext)_localctx).iw.iw;
						_localctx.oIW.setPos( _localctx.oIW.getPos() );
						_localctx.oIW.setRefType( RefType.OBJECT );
						((ORefIndContext)_localctx).il =  ((ORefIndContext)_localctx).iw.il + 1; // +1 -> star
					
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ERefIndContext extends ParserRuleContext {
		public IndexedWord eIW;
		public int il;
		public IndexedWordContext iw;
		public TerminalNode TILDE() { return getToken(CommandLineGrammarParser.TILDE, 0); }
		public IndexedWordContext indexedWord() {
			return getRuleContext(IndexedWordContext.class,0);
		}
		public ERefIndContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_eRefInd; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterERefInd(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitERefInd(this);
		}
	}

	public final ERefIndContext eRefInd() throws RecognitionException {
		ERefIndContext _localctx = new ERefIndContext(_ctx, getState());
		enterRule(_localctx, 130, RULE_eRefInd);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1154); match(TILDE);
			setState(1155); ((ERefIndContext)_localctx).iw = indexedWord();

						((ERefIndContext)_localctx).eIW =  ((ERefIndContext)_localctx).iw.iw;
						_localctx.eIW.setPos( _localctx.eIW.getPos() );
						_localctx.eIW.setRefType( RefType.ENTITY );
						((ERefIndContext)_localctx).il =  ((ERefIndContext)_localctx).iw.il + 1; // +1 -> tilde
					
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IndexedWordContext extends ParserRuleContext {
		public IndexedWord iw;
		public int il;
		public IntegerContext i;
		public WordContext w;
		public WordContext word() {
			return getRuleContext(WordContext.class,0);
		}
		public TerminalNode DOT() { return getToken(CommandLineGrammarParser.DOT, 0); }
		public IntegerContext integer() {
			return getRuleContext(IntegerContext.class,0);
		}
		public IndexedWordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_indexedWord; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterIndexedWord(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitIndexedWord(this);
		}
	}

	public final IndexedWordContext indexedWord() throws RecognitionException {
		IndexedWordContext _localctx = new IndexedWordContext(_ctx, getState());
		enterRule(_localctx, 132, RULE_indexedWord);
		try {
			setState(1166);
			switch (_input.LA(1)) {
			case INTEGER:
				enterOuterAlt(_localctx, 1);
				{
				setState(1158); ((IndexedWordContext)_localctx).i = integer();
				setState(1159); match(DOT);
				setState(1160); ((IndexedWordContext)_localctx).w = word();

							((IndexedWordContext)_localctx).iw =  new IndexedWord( ((IndexedWordContext)_localctx).i.s + "." + (((IndexedWordContext)_localctx).w!=null?_input.getText(((IndexedWordContext)_localctx).w.start,((IndexedWordContext)_localctx).w.stop):null), ((IndexedWordContext)_localctx).i.si );
							((IndexedWordContext)_localctx).il =  Integer.toString( ((IndexedWordContext)_localctx).i.s ).length() + 1;
						
				}
				break;
			case WORD:
				enterOuterAlt(_localctx, 2);
				{
				setState(1163); ((IndexedWordContext)_localctx).w = word();

							((IndexedWordContext)_localctx).iw =  new IndexedWord( (((IndexedWordContext)_localctx).w!=null?_input.getText(((IndexedWordContext)_localctx).w.start,((IndexedWordContext)_localctx).w.stop):null), ((IndexedWordContext)_localctx).w.si );
							((IndexedWordContext)_localctx).il =  0;
						
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WordContext extends ParserRuleContext {
		public int si;
		public Token WORD;
		public TerminalNode WORD() { return getToken(CommandLineGrammarParser.WORD, 0); }
		public WordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_word; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterWord(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitWord(this);
		}
	}

	public final WordContext word() throws RecognitionException {
		WordContext _localctx = new WordContext(_ctx, getState());
		enterRule(_localctx, 134, RULE_word);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1168); ((WordContext)_localctx).WORD = match(WORD);

						((WordContext)_localctx).si =  ((WordContext)_localctx).WORD.getStartIndex();
					
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PunctuationContext extends ParserRuleContext {
		public String s;
		public Token PUNCTUATION;
		public TerminalNode PUNCTUATION() { return getToken(CommandLineGrammarParser.PUNCTUATION, 0); }
		public PunctuationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_punctuation; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterPunctuation(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitPunctuation(this);
		}
	}

	public final PunctuationContext punctuation() throws RecognitionException {
		PunctuationContext _localctx = new PunctuationContext(_ctx, getState());
		enterRule(_localctx, 136, RULE_punctuation);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1171); ((PunctuationContext)_localctx).PUNCTUATION = match(PUNCTUATION);

						((PunctuationContext)_localctx).s =  (((PunctuationContext)_localctx).PUNCTUATION!=null?((PunctuationContext)_localctx).PUNCTUATION.getText():null);
					
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IntegerContext extends ParserRuleContext {
		public int s;
		public int si;
		public Token INTEGER;
		public TerminalNode INTEGER() { return getToken(CommandLineGrammarParser.INTEGER, 0); }
		public IntegerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_integer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterInteger(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitInteger(this);
		}
	}

	public final IntegerContext integer() throws RecognitionException {
		IntegerContext _localctx = new IntegerContext(_ctx, getState());
		enterRule(_localctx, 138, RULE_integer);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1174); ((IntegerContext)_localctx).INTEGER = match(INTEGER);

						((IntegerContext)_localctx).s =  Integer.parseInt( (((IntegerContext)_localctx).INTEGER!=null?((IntegerContext)_localctx).INTEGER.getText():null) );
						((IntegerContext)_localctx).si =  ((IntegerContext)_localctx).INTEGER.getStartIndex();
					
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AimedDirectionContext extends ParserRuleContext {
		public Direction d;
		public TerminalNode GO_EAST() { return getToken(CommandLineGrammarParser.GO_EAST, 0); }
		public TerminalNode GO_NORTH() { return getToken(CommandLineGrammarParser.GO_NORTH, 0); }
		public TerminalNode GO_SOUTH() { return getToken(CommandLineGrammarParser.GO_SOUTH, 0); }
		public TerminalNode GO_WEST() { return getToken(CommandLineGrammarParser.GO_WEST, 0); }
		public TerminalNode GO_UP() { return getToken(CommandLineGrammarParser.GO_UP, 0); }
		public TerminalNode GO_DOWN() { return getToken(CommandLineGrammarParser.GO_DOWN, 0); }
		public AimedDirectionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aimedDirection; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).enterAimedDirection(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CommandLineGrammarListener ) ((CommandLineGrammarListener)listener).exitAimedDirection(this);
		}
	}

	public final AimedDirectionContext aimedDirection() throws RecognitionException {
		AimedDirectionContext _localctx = new AimedDirectionContext(_ctx, getState());
		enterRule(_localctx, 140, RULE_aimedDirection);
		try {
			setState(1189);
			switch (_input.LA(1)) {
			case GO_NORTH:
				enterOuterAlt(_localctx, 1);
				{
				setState(1177); match(GO_NORTH);

						((AimedDirectionContext)_localctx).d =  Direction.NORTH;
					
				}
				break;
			case GO_EAST:
				enterOuterAlt(_localctx, 2);
				{
				setState(1179); match(GO_EAST);

						((AimedDirectionContext)_localctx).d =  Direction.EAST;
					
				}
				break;
			case GO_SOUTH:
				enterOuterAlt(_localctx, 3);
				{
				setState(1181); match(GO_SOUTH);

						((AimedDirectionContext)_localctx).d =  Direction.SOUTH;
					
				}
				break;
			case GO_WEST:
				enterOuterAlt(_localctx, 4);
				{
				setState(1183); match(GO_WEST);

						((AimedDirectionContext)_localctx).d =  Direction.WEST;
					
				}
				break;
			case GO_UP:
				enterOuterAlt(_localctx, 5);
				{
				setState(1185); match(GO_UP);

						((AimedDirectionContext)_localctx).d =  Direction.UP;
					
				}
				break;
			case GO_DOWN:
				enterOuterAlt(_localctx, 6);
				{
				setState(1187); match(GO_DOWN);

						((AimedDirectionContext)_localctx).d =  Direction.DOWN;
					
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3A\u04aa\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\3\2"+
		"\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3"+
		"\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2"+
		"\3\2\3\2\3\2\3\2\3\2\5\2\u00ba\n\2\3\3\5\3\u00bd\n\3\3\3\3\3\3\3\3\3\3"+
		"\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00cb\n\3\3\3\5\3\u00ce\n\3\3\3\5\3"+
		"\u00d1\n\3\3\3\5\3\u00d4\n\3\3\3\3\3\3\4\5\4\u00d9\n\4\3\4\3\4\3\4\3\4"+
		"\3\4\3\4\5\4\u00e1\n\4\3\4\3\4\3\5\5\5\u00e6\n\5\3\5\3\5\3\5\3\5\5\5\u00ec"+
		"\n\5\3\5\3\5\3\6\5\6\u00f1\n\6\3\6\3\6\3\6\3\6\5\6\u00f7\n\6\3\6\3\6\3"+
		"\7\3\7\5\7\u00fd\n\7\3\b\5\b\u0100\n\b\3\b\3\b\3\b\3\b\5\b\u0106\n\b\3"+
		"\b\5\b\u0109\n\b\3\b\5\b\u010c\n\b\3\b\3\b\3\t\5\t\u0111\n\t\3\t\3\t\3"+
		"\t\3\t\3\t\3\t\5\t\u0119\n\t\3\t\5\t\u011c\n\t\3\t\5\t\u011f\n\t\3\t\5"+
		"\t\u0122\n\t\3\t\5\t\u0125\n\t\3\t\3\t\3\n\5\n\u012a\n\n\3\n\3\n\3\n\3"+
		"\n\3\n\3\n\5\n\u0132\n\n\3\n\3\n\5\n\u0136\n\n\5\n\u0138\n\n\3\n\5\n\u013b"+
		"\n\n\3\n\5\n\u013e\n\n\3\n\3\n\3\13\5\13\u0143\n\13\3\13\3\13\3\13\3\13"+
		"\5\13\u0149\n\13\3\13\5\13\u014c\n\13\3\13\5\13\u014f\n\13\3\13\3\13\3"+
		"\f\5\f\u0154\n\f\3\f\3\f\3\f\3\f\3\f\3\f\5\f\u015c\n\f\3\f\5\f\u015f\n"+
		"\f\3\f\5\f\u0162\n\f\3\f\3\f\3\r\5\r\u0167\n\r\3\r\3\r\5\r\u016b\n\r\3"+
		"\r\3\r\3\r\3\r\5\r\u0171\n\r\3\16\5\16\u0174\n\16\3\16\3\16\3\16\3\16"+
		"\3\16\5\16\u017b\n\16\3\16\5\16\u017e\n\16\3\16\5\16\u0181\n\16\3\16\5"+
		"\16\u0184\n\16\3\16\5\16\u0187\n\16\3\16\5\16\u018a\n\16\3\16\3\16\3\17"+
		"\5\17\u018f\n\17\3\17\3\17\3\17\3\17\3\17\5\17\u0196\n\17\3\17\5\17\u0199"+
		"\n\17\3\17\5\17\u019c\n\17\3\17\5\17\u019f\n\17\3\17\5\17\u01a2\n\17\3"+
		"\17\5\17\u01a5\n\17\3\17\3\17\3\20\5\20\u01aa\n\20\3\20\3\20\3\20\3\20"+
		"\5\20\u01b0\n\20\3\20\5\20\u01b3\n\20\3\20\5\20\u01b6\n\20\3\20\3\20\3"+
		"\21\5\21\u01bb\n\21\3\21\3\21\5\21\u01bf\n\21\3\21\3\21\5\21\u01c3\n\21"+
		"\3\21\3\21\5\21\u01c7\n\21\3\21\5\21\u01ca\n\21\3\21\5\21\u01cd\n\21\3"+
		"\21\3\21\3\22\5\22\u01d2\n\22\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u01da"+
		"\n\22\3\22\3\22\3\23\5\23\u01df\n\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+
		"\5\23\u01e8\n\23\3\23\5\23\u01eb\n\23\3\23\5\23\u01ee\n\23\3\23\5\23\u01f1"+
		"\n\23\3\23\3\23\3\24\5\24\u01f6\n\24\3\24\3\24\3\24\3\24\3\24\5\24\u01fd"+
		"\n\24\3\24\3\24\3\24\5\24\u0202\n\24\3\24\5\24\u0205\n\24\5\24\u0207\n"+
		"\24\3\24\5\24\u020a\n\24\3\24\5\24\u020d\n\24\3\24\5\24\u0210\n\24\3\24"+
		"\3\24\3\25\5\25\u0215\n\25\3\25\3\25\3\25\3\25\5\25\u021b\n\25\3\25\5"+
		"\25\u021e\n\25\3\25\5\25\u0221\n\25\3\25\3\25\3\26\5\26\u0226\n\26\3\26"+
		"\3\26\5\26\u022a\n\26\3\26\5\26\u022d\n\26\3\26\5\26\u0230\n\26\3\26\3"+
		"\26\3\27\5\27\u0235\n\27\3\27\3\27\3\27\3\27\3\27\3\27\5\27\u023d\n\27"+
		"\3\27\5\27\u0240\n\27\3\27\5\27\u0243\n\27\3\27\3\27\3\30\5\30\u0248\n"+
		"\30\3\30\3\30\5\30\u024c\n\30\3\30\3\30\5\30\u0250\n\30\3\30\3\30\3\31"+
		"\5\31\u0255\n\31\3\31\3\31\5\31\u0259\n\31\3\31\3\31\3\32\5\32\u025e\n"+
		"\32\3\32\3\32\3\32\5\32\u0263\n\32\3\32\5\32\u0266\n\32\3\32\3\32\3\33"+
		"\5\33\u026b\n\33\3\33\3\33\5\33\u026f\n\33\3\34\3\34\5\34\u0273\n\34\3"+
		"\35\5\35\u0276\n\35\3\35\3\35\3\35\3\35\5\35\u027c\n\35\3\35\5\35\u027f"+
		"\n\35\3\35\5\35\u0282\n\35\3\35\3\35\3\36\5\36\u0287\n\36\3\36\3\36\3"+
		"\36\3\36\5\36\u028d\n\36\3\36\5\36\u0290\n\36\3\36\5\36\u0293\n\36\3\36"+
		"\5\36\u0296\n\36\3\36\5\36\u0299\n\36\3\36\3\36\3\37\3\37\5\37\u029f\n"+
		"\37\3 \5 \u02a2\n \3 \3 \3 \3 \5 \u02a8\n \3 \5 \u02ab\n \3 \5 \u02ae"+
		"\n \3 \3 \3!\5!\u02b3\n!\3!\3!\3!\3!\5!\u02b9\n!\3!\5!\u02bc\n!\3!\5!"+
		"\u02bf\n!\3!\5!\u02c2\n!\3!\5!\u02c5\n!\3!\3!\3\"\3\"\5\"\u02cb\n\"\3"+
		"#\5#\u02ce\n#\3#\3#\3#\3#\5#\u02d4\n#\3#\5#\u02d7\n#\3#\5#\u02da\n#\3"+
		"#\3#\3$\5$\u02df\n$\3$\3$\3$\3$\5$\u02e5\n$\3$\5$\u02e8\n$\3$\5$\u02eb"+
		"\n$\3$\5$\u02ee\n$\3$\5$\u02f1\n$\3$\3$\3%\3%\5%\u02f7\n%\3&\5&\u02fa"+
		"\n&\3&\3&\3&\3&\5&\u0300\n&\3&\5&\u0303\n&\3&\5&\u0306\n&\3&\3&\3\'\5"+
		"\'\u030b\n\'\3\'\3\'\3\'\3\'\5\'\u0311\n\'\3\'\5\'\u0314\n\'\3\'\5\'\u0317"+
		"\n\'\3\'\5\'\u031a\n\'\3\'\5\'\u031d\n\'\3\'\3\'\3(\3(\5(\u0323\n(\3)"+
		"\5)\u0326\n)\3)\3)\3)\3)\5)\u032c\n)\3)\3)\5)\u0330\n)\3)\5)\u0333\n)"+
		"\3)\3)\5)\u0337\n)\3)\5)\u033a\n)\3)\5)\u033d\n)\3)\3)\3*\5*\u0342\n*"+
		"\3*\3*\3*\3*\5*\u0348\n*\3*\3*\5*\u034c\n*\3*\5*\u034f\n*\3*\3*\5*\u0353"+
		"\n*\3*\3*\3+\5+\u0358\n+\3+\3+\3+\3+\5+\u035e\n+\3+\3+\3,\5,\u0363\n,"+
		"\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\5,\u0375\n,\5,\u0377"+
		"\n,\3,\5,\u037a\n,\3-\5-\u037d\n-\3-\3-\5-\u0381\n-\3.\5.\u0384\n.\3."+
		"\3.\3.\3.\3.\5.\u038b\n.\3.\5.\u038e\n.\3.\5.\u0391\n.\3.\5.\u0394\n."+
		"\3.\3.\3/\5/\u0399\n/\3/\3/\3/\3/\5/\u039f\n/\3/\5/\u03a2\n/\3/\5/\u03a5"+
		"\n/\3/\3/\3\60\5\60\u03aa\n\60\3\60\3\60\5\60\u03ae\n\60\3\61\5\61\u03b1"+
		"\n\61\3\61\3\61\5\61\u03b5\n\61\3\62\5\62\u03b8\n\62\3\62\3\62\3\62\3"+
		"\62\3\62\3\62\5\62\u03c0\n\62\3\62\3\62\3\62\3\62\3\62\5\62\u03c7\n\62"+
		"\3\62\5\62\u03ca\n\62\3\63\5\63\u03cd\n\63\3\63\3\63\3\63\3\63\5\63\u03d3"+
		"\n\63\3\63\3\63\3\64\5\64\u03d8\n\64\3\64\3\64\5\64\u03dc\n\64\3\65\5"+
		"\65\u03df\n\65\3\65\3\65\3\65\3\65\5\65\u03e5\n\65\3\65\3\65\3\66\5\66"+
		"\u03ea\n\66\3\66\3\66\5\66\u03ee\n\66\3\67\5\67\u03f1\n\67\3\67\3\67\3"+
		"\67\3\67\5\67\u03f7\n\67\3\67\3\67\38\58\u03fc\n8\38\38\58\u0400\n8\3"+
		"9\39\39\39\39\39\39\39\59\u040a\n9\3:\5:\u040d\n:\3:\3:\3:\3:\3:\7:\u0414"+
		"\n:\f:\16:\u0417\13:\3:\5:\u041a\n:\3;\5;\u041d\n;\3;\3;\3;\3;\3;\7;\u0424"+
		"\n;\f;\16;\u0427\13;\3;\5;\u042a\n;\3<\5<\u042d\n<\3<\3<\3<\3<\3<\5<\u0434"+
		"\n<\3<\5<\u0437\n<\3<\3<\3=\5=\u043c\n=\3=\3=\5=\u0440\n=\3>\3>\3>\3>"+
		"\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>"+
		"\3>\7>\u045e\n>\f>\16>\u0461\13>\3>\3>\3?\5?\u0466\n?\3?\5?\u0469\n?\3"+
		"?\3?\5?\u046d\n?\5?\u046f\n?\3?\3?\3@\7@\u0474\n@\f@\16@\u0477\13@\3A"+
		"\3A\3A\3A\3A\3A\5A\u047f\nA\3B\3B\3B\3B\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D"+
		"\3D\3D\5D\u0491\nD\3E\3E\3E\3F\3F\3F\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H"+
		"\3H\3H\3H\3H\5H\u04a8\nH\3H\3\u0475\2I\2\4\6\b\n\f\16\20\22\24\26\30\32"+
		"\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080"+
		"\u0082\u0084\u0086\u0088\u008a\u008c\u008e\2\2\u057c\2\u00b9\3\2\2\2\4"+
		"\u00bc\3\2\2\2\6\u00d8\3\2\2\2\b\u00e5\3\2\2\2\n\u00f0\3\2\2\2\f\u00fc"+
		"\3\2\2\2\16\u00ff\3\2\2\2\20\u0110\3\2\2\2\22\u0129\3\2\2\2\24\u0142\3"+
		"\2\2\2\26\u0153\3\2\2\2\30\u0170\3\2\2\2\32\u0173\3\2\2\2\34\u018e\3\2"+
		"\2\2\36\u01a9\3\2\2\2 \u01ba\3\2\2\2\"\u01d1\3\2\2\2$\u01de\3\2\2\2&\u01f5"+
		"\3\2\2\2(\u0214\3\2\2\2*\u0225\3\2\2\2,\u0234\3\2\2\2.\u0247\3\2\2\2\60"+
		"\u0254\3\2\2\2\62\u025d\3\2\2\2\64\u026a\3\2\2\2\66\u0272\3\2\2\28\u0275"+
		"\3\2\2\2:\u0286\3\2\2\2<\u029e\3\2\2\2>\u02a1\3\2\2\2@\u02b2\3\2\2\2B"+
		"\u02ca\3\2\2\2D\u02cd\3\2\2\2F\u02de\3\2\2\2H\u02f6\3\2\2\2J\u02f9\3\2"+
		"\2\2L\u030a\3\2\2\2N\u0322\3\2\2\2P\u0325\3\2\2\2R\u0341\3\2\2\2T\u0357"+
		"\3\2\2\2V\u0362\3\2\2\2X\u037c\3\2\2\2Z\u0383\3\2\2\2\\\u0398\3\2\2\2"+
		"^\u03a9\3\2\2\2`\u03b0\3\2\2\2b\u03b7\3\2\2\2d\u03cc\3\2\2\2f\u03d7\3"+
		"\2\2\2h\u03de\3\2\2\2j\u03e9\3\2\2\2l\u03f0\3\2\2\2n\u03fb\3\2\2\2p\u0409"+
		"\3\2\2\2r\u040c\3\2\2\2t\u041c\3\2\2\2v\u042c\3\2\2\2x\u043b\3\2\2\2z"+
		"\u0441\3\2\2\2|\u0465\3\2\2\2~\u0475\3\2\2\2\u0080\u047e\3\2\2\2\u0082"+
		"\u0480\3\2\2\2\u0084\u0484\3\2\2\2\u0086\u0490\3\2\2\2\u0088\u0492\3\2"+
		"\2\2\u008a\u0495\3\2\2\2\u008c\u0498\3\2\2\2\u008e\u04a7\3\2\2\2\u0090"+
		"\u00ba\3\2\2\2\u0091\u00ba\5\b\5\2\u0092\u00ba\5\6\4\2\u0093\u00ba\5\n"+
		"\6\2\u0094\u00ba\5\4\3\2\u0095\u00ba\5\f\7\2\u0096\u00ba\5.\30\2\u0097"+
		"\u00ba\5\22\n\2\u0098\u00ba\5\24\13\2\u0099\u00ba\5\26\f\2\u009a\u00ba"+
		"\5\30\r\2\u009b\u00ba\5\32\16\2\u009c\u00ba\5\34\17\2\u009d\u00ba\5,\27"+
		"\2\u009e\u00ba\5\60\31\2\u009f\u00ba\5\62\32\2\u00a0\u00ba\5\64\33\2\u00a1"+
		"\u00ba\5f\64\2\u00a2\u00ba\5\66\34\2\u00a3\u00ba\5<\37\2\u00a4\u00ba\5"+
		"B\"\2\u00a5\u00ba\5H%\2\u00a6\u00ba\5&\24\2\u00a7\u00ba\5$\23\2\u00a8"+
		"\u00ba\5(\25\2\u00a9\u00ba\5Z.\2\u00aa\u00ba\5\\/\2\u00ab\u00ba\5^\60"+
		"\2\u00ac\u00ba\5`\61\2\u00ad\u00ba\5b\62\2\u00ae\u00ba\5*\26\2\u00af\u00ba"+
		"\5N(\2\u00b0\u00ba\5h\65\2\u00b1\u00ba\5T+\2\u00b2\u00ba\5V,\2\u00b3\u00ba"+
		"\5X-\2\u00b4\u00ba\5l\67\2\u00b5\u00ba\5j\66\2\u00b6\u00ba\5n8\2\u00b7"+
		"\u00ba\5d\63\2\u00b8\u00ba\5p9\2\u00b9\u0090\3\2\2\2\u00b9\u0091\3\2\2"+
		"\2\u00b9\u0092\3\2\2\2\u00b9\u0093\3\2\2\2\u00b9\u0094\3\2\2\2\u00b9\u0095"+
		"\3\2\2\2\u00b9\u0096\3\2\2\2\u00b9\u0097\3\2\2\2\u00b9\u0098\3\2\2\2\u00b9"+
		"\u0099\3\2\2\2\u00b9\u009a\3\2\2\2\u00b9\u009b\3\2\2\2\u00b9\u009c\3\2"+
		"\2\2\u00b9\u009d\3\2\2\2\u00b9\u009e\3\2\2\2\u00b9\u009f\3\2\2\2\u00b9"+
		"\u00a0\3\2\2\2\u00b9\u00a1\3\2\2\2\u00b9\u00a2\3\2\2\2\u00b9\u00a3\3\2"+
		"\2\2\u00b9\u00a4\3\2\2\2\u00b9\u00a5\3\2\2\2\u00b9\u00a6\3\2\2\2\u00b9"+
		"\u00a7\3\2\2\2\u00b9\u00a8\3\2\2\2\u00b9\u00a9\3\2\2\2\u00b9\u00aa\3\2"+
		"\2\2\u00b9\u00ab\3\2\2\2\u00b9\u00ac\3\2\2\2\u00b9\u00ad\3\2\2\2\u00b9"+
		"\u00ae\3\2\2\2\u00b9\u00af\3\2\2\2\u00b9\u00b0\3\2\2\2\u00b9\u00b1\3\2"+
		"\2\2\u00b9\u00b2\3\2\2\2\u00b9\u00b3\3\2\2\2\u00b9\u00b4\3\2\2\2\u00b9"+
		"\u00b5\3\2\2\2\u00b9\u00b6\3\2\2\2\u00b9\u00b7\3\2\2\2\u00b9\u00b8\3\2"+
		"\2\2\u00ba\3\3\2\2\2\u00bb\u00bd\7A\2\2\u00bc\u00bb\3\2\2\2\u00bc\u00bd"+
		"\3\2\2\2\u00bd\u00ca\3\2\2\2\u00be\u00bf\7\6\2\2\u00bf\u00cb\b\3\1\2\u00c0"+
		"\u00c1\7\b\2\2\u00c1\u00cb\b\3\1\2\u00c2\u00c3\7\t\2\2\u00c3\u00cb\b\3"+
		"\1\2\u00c4\u00c5\7\7\2\2\u00c5\u00cb\b\3\1\2\u00c6\u00c7\7\n\2\2\u00c7"+
		"\u00cb\b\3\1\2\u00c8\u00c9\7\13\2\2\u00c9\u00cb\b\3\1\2\u00ca\u00be\3"+
		"\2\2\2\u00ca\u00c0\3\2\2\2\u00ca\u00c2\3\2\2\2\u00ca\u00c4\3\2\2\2\u00ca"+
		"\u00c6\3\2\2\2\u00ca\u00c8\3\2\2\2\u00cb\u00cd\3\2\2\2\u00cc\u00ce\7A"+
		"\2\2\u00cd\u00cc\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00d0\3\2\2\2\u00cf"+
		"\u00d1\5z>\2\u00d0\u00cf\3\2\2\2\u00d0\u00d1\3\2\2\2\u00d1\u00d3\3\2\2"+
		"\2\u00d2\u00d4\7A\2\2\u00d3\u00d2\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d4\u00d5"+
		"\3\2\2\2\u00d5\u00d6\b\3\1\2\u00d6\5\3\2\2\2\u00d7\u00d9\7A\2\2\u00d8"+
		"\u00d7\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00da\3\2\2\2\u00da\u00db\7\4"+
		"\2\2\u00db\u00dc\7A\2\2\u00dc\u00dd\5\u0086D\2\u00dd\u00de\5|?\2\u00de"+
		"\u00e0\5~@\2\u00df\u00e1\7A\2\2\u00e0\u00df\3\2\2\2\u00e0\u00e1\3\2\2"+
		"\2\u00e1\u00e2\3\2\2\2\u00e2\u00e3\b\4\1\2\u00e3\7\3\2\2\2\u00e4\u00e6"+
		"\7A\2\2\u00e5\u00e4\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7"+
		"\u00e8\7\3\2\2\u00e8\u00e9\5|?\2\u00e9\u00eb\5~@\2\u00ea\u00ec\7A\2\2"+
		"\u00eb\u00ea\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00ee"+
		"\b\5\1\2\u00ee\t\3\2\2\2\u00ef\u00f1\7A\2\2\u00f0\u00ef\3\2\2\2\u00f0"+
		"\u00f1\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f3\7\5\2\2\u00f3\u00f4\5|"+
		"?\2\u00f4\u00f6\5~@\2\u00f5\u00f7\7A\2\2\u00f6\u00f5\3\2\2\2\u00f6\u00f7"+
		"\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u00f9\b\6\1\2\u00f9\13\3\2\2\2\u00fa"+
		"\u00fd\5\16\b\2\u00fb\u00fd\5\20\t\2\u00fc\u00fa\3\2\2\2\u00fc\u00fb\3"+
		"\2\2\2\u00fd\r\3\2\2\2\u00fe\u0100\7A\2\2\u00ff\u00fe\3\2\2\2\u00ff\u0100"+
		"\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0102\7\f\2\2\u0102\u0103\7A\2\2\u0103"+
		"\u0108\5\u0086D\2\u0104\u0106\7A\2\2\u0105\u0104\3\2\2\2\u0105\u0106\3"+
		"\2\2\2\u0106\u0107\3\2\2\2\u0107\u0109\5z>\2\u0108\u0105\3\2\2\2\u0108"+
		"\u0109\3\2\2\2\u0109\u010b\3\2\2\2\u010a\u010c\7A\2\2\u010b\u010a\3\2"+
		"\2\2\u010b\u010c\3\2\2\2\u010c\u010d\3\2\2\2\u010d\u010e\b\b\1\2\u010e"+
		"\17\3\2\2\2\u010f\u0111\7A\2\2\u0110\u010f\3\2\2\2\u0110\u0111\3\2\2\2"+
		"\u0111\u0112\3\2\2\2\u0112\u0113\7\f\2\2\u0113\u0114\7A\2\2\u0114\u0115"+
		"\5\u0086D\2\u0115\u0116\7A\2\2\u0116\u011b\5\u0086D\2\u0117\u0119\7A\2"+
		"\2\u0118\u0117\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011a\3\2\2\2\u011a\u011c"+
		"\7<\2\2\u011b\u0118\3\2\2\2\u011b\u011c\3\2\2\2\u011c\u0121\3\2\2\2\u011d"+
		"\u011f\7A\2\2\u011e\u011d\3\2\2\2\u011e\u011f\3\2\2\2\u011f\u0120\3\2"+
		"\2\2\u0120\u0122\5z>\2\u0121\u011e\3\2\2\2\u0121\u0122\3\2\2\2\u0122\u0124"+
		"\3\2\2\2\u0123\u0125\7A\2\2\u0124\u0123\3\2\2\2\u0124\u0125\3\2\2\2\u0125"+
		"\u0126\3\2\2\2\u0126\u0127\b\t\1\2\u0127\21\3\2\2\2\u0128\u012a\7A\2\2"+
		"\u0129\u0128\3\2\2\2\u0129\u012a\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012c"+
		"\7\r\2\2\u012c\u012d\7A\2\2\u012d\u012e\5\u0086D\2\u012e\u012f\7A\2\2"+
		"\u012f\u0131\5\u0086D\2\u0130\u0132\7A\2\2\u0131\u0130\3\2\2\2\u0131\u0132"+
		"\3\2\2\2\u0132\u0137\3\2\2\2\u0133\u0135\7<\2\2\u0134\u0136\7A\2\2\u0135"+
		"\u0134\3\2\2\2\u0135\u0136\3\2\2\2\u0136\u0138\3\2\2\2\u0137\u0133\3\2"+
		"\2\2\u0137\u0138\3\2\2\2\u0138\u013a\3\2\2\2\u0139\u013b\5z>\2\u013a\u0139"+
		"\3\2\2\2\u013a\u013b\3\2\2\2\u013b\u013d\3\2\2\2\u013c\u013e\7A\2\2\u013d"+
		"\u013c\3\2\2\2\u013d\u013e\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u0140\b\n"+
		"\1\2\u0140\23\3\2\2\2\u0141\u0143\7A\2\2\u0142\u0141\3\2\2\2\u0142\u0143"+
		"\3\2\2\2\u0143\u0144\3\2\2\2\u0144\u0145\7\16\2\2\u0145\u0146\7A\2\2\u0146"+
		"\u014b\5\u0086D\2\u0147\u0149\7A\2\2\u0148\u0147\3\2\2\2\u0148\u0149\3"+
		"\2\2\2\u0149\u014a\3\2\2\2\u014a\u014c\5z>\2\u014b\u0148\3\2\2\2\u014b"+
		"\u014c\3\2\2\2\u014c\u014e\3\2\2\2\u014d\u014f\7A\2\2\u014e\u014d\3\2"+
		"\2\2\u014e\u014f\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0151\b\13\1\2\u0151"+
		"\25\3\2\2\2\u0152\u0154\7A\2\2\u0153\u0152\3\2\2\2\u0153\u0154\3\2\2\2"+
		"\u0154\u0155\3\2\2\2\u0155\u0156\7\17\2\2\u0156\u0157\7A\2\2\u0157\u0158"+
		"\5\u0086D\2\u0158\u0159\7A\2\2\u0159\u015e\5\u0086D\2\u015a\u015c\7A\2"+
		"\2\u015b\u015a\3\2\2\2\u015b\u015c\3\2\2\2\u015c\u015d\3\2\2\2\u015d\u015f"+
		"\5z>\2\u015e\u015b\3\2\2\2\u015e\u015f\3\2\2\2\u015f\u0161\3\2\2\2\u0160"+
		"\u0162\7A\2\2\u0161\u0160\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0163\3\2"+
		"\2\2\u0163\u0164\b\f\1\2\u0164\27\3\2\2\2\u0165\u0167\7A\2\2\u0166\u0165"+
		"\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0168\3\2\2\2\u0168\u016a\7!\2\2\u0169"+
		"\u016b\7A\2\2\u016a\u0169\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u016c\3\2"+
		"\2\2\u016c\u0171\b\r\1\2\u016d\u0171\5\36\20\2\u016e\u0171\5 \21\2\u016f"+
		"\u0171\5\"\22\2\u0170\u0166\3\2\2\2\u0170\u016d\3\2\2\2\u0170\u016e\3"+
		"\2\2\2\u0170\u016f\3\2\2\2\u0171\31\3\2\2\2\u0172\u0174\7A\2\2\u0173\u0172"+
		"\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0175\3\2\2\2\u0175\u0176\7\26\2\2"+
		"\u0176\u0177\7A\2\2\u0177\u017a\5\u0086D\2\u0178\u0179\7A\2\2\u0179\u017b"+
		"\5\u008cG\2\u017a\u0178\3\2\2\2\u017a\u017b\3\2\2\2\u017b\u0180\3\2\2"+
		"\2\u017c\u017e\7A\2\2\u017d\u017c\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u017f"+
		"\3\2\2\2\u017f\u0181\7<\2\2\u0180\u017d\3\2\2\2\u0180\u0181\3\2\2\2\u0181"+
		"\u0186\3\2\2\2\u0182\u0184\7A\2\2\u0183\u0182\3\2\2\2\u0183\u0184\3\2"+
		"\2\2\u0184\u0185\3\2\2\2\u0185\u0187\5z>\2\u0186\u0183\3\2\2\2\u0186\u0187"+
		"\3\2\2\2\u0187\u0189\3\2\2\2\u0188\u018a\7A\2\2\u0189\u0188\3\2\2\2\u0189"+
		"\u018a\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018c\b\16\1\2\u018c\33\3\2\2"+
		"\2\u018d\u018f\7A\2\2\u018e\u018d\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u0190"+
		"\3\2\2\2\u0190\u0191\7\27\2\2\u0191\u0192\7A\2\2\u0192\u0195\5\u0086D"+
		"\2\u0193\u0194\7A\2\2\u0194\u0196\5\u008cG\2\u0195\u0193\3\2\2\2\u0195"+
		"\u0196\3\2\2\2\u0196\u019b\3\2\2\2\u0197\u0199\7A\2\2\u0198\u0197\3\2"+
		"\2\2\u0198\u0199\3\2\2\2\u0199\u019a\3\2\2\2\u019a\u019c\7<\2\2\u019b"+
		"\u0198\3\2\2\2\u019b\u019c\3\2\2\2\u019c\u01a1\3\2\2\2\u019d\u019f\7A"+
		"\2\2\u019e\u019d\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0"+
		"\u01a2\5z>\2\u01a1\u019e\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\u01a4\3\2\2"+
		"\2\u01a3\u01a5\7A\2\2\u01a4\u01a3\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a6"+
		"\3\2\2\2\u01a6\u01a7\b\17\1\2\u01a7\35\3\2\2\2\u01a8\u01aa\7A\2\2\u01a9"+
		"\u01a8\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\7!"+
		"\2\2\u01ac\u01ad\7A\2\2\u01ad\u01b2\5\u0086D\2\u01ae\u01b0\7A\2\2\u01af"+
		"\u01ae\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b3\7<"+
		"\2\2\u01b2\u01af\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b3\u01b5\3\2\2\2\u01b4"+
		"\u01b6\7A\2\2\u01b5\u01b4\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b7\3\2"+
		"\2\2\u01b7\u01b8\b\20\1\2\u01b8\37\3\2\2\2\u01b9\u01bb\7A\2\2\u01ba\u01b9"+
		"\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\u01be\7!\2\2\u01bd"+
		"\u01bf\7A\2\2\u01be\u01bd\3\2\2\2\u01be\u01bf\3\2\2\2\u01bf\u01c0\3\2"+
		"\2\2\u01c0\u01c2\7<\2\2\u01c1\u01c3\7A\2\2\u01c2\u01c1\3\2\2\2\u01c2\u01c3"+
		"\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01c9\5\u0086D\2\u01c5\u01c7\7A\2\2"+
		"\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01ca"+
		"\7<\2\2\u01c9\u01c6\3\2\2\2\u01c9\u01ca\3\2\2\2\u01ca\u01cc\3\2\2\2\u01cb"+
		"\u01cd\7A\2\2\u01cc\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01ce\3\2"+
		"\2\2\u01ce\u01cf\b\21\1\2\u01cf!\3\2\2\2\u01d0\u01d2\7A\2\2\u01d1\u01d0"+
		"\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d4\7!\2\2\u01d4"+
		"\u01d5\7A\2\2\u01d5\u01d6\5\u0086D\2\u01d6\u01d7\7A\2\2\u01d7\u01d9\5"+
		"\u0086D\2\u01d8\u01da\7A\2\2\u01d9\u01d8\3\2\2\2\u01d9\u01da\3\2\2\2\u01da"+
		"\u01db\3\2\2\2\u01db\u01dc\b\22\1\2\u01dc#\3\2\2\2\u01dd\u01df\7A\2\2"+
		"\u01de\u01dd\3\2\2\2\u01de\u01df\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0\u01e1"+
		"\7\21\2\2\u01e1\u01e2\7A\2\2\u01e2\u01e3\5\u0086D\2\u01e3\u01e4\7A\2\2"+
		"\u01e4\u01e7\5\u0086D\2\u01e5\u01e6\7A\2\2\u01e6\u01e8\7<\2\2\u01e7\u01e5"+
		"\3\2\2\2\u01e7\u01e8\3\2\2\2\u01e8\u01ed\3\2\2\2\u01e9\u01eb\7A\2\2\u01ea"+
		"\u01e9\3\2\2\2\u01ea\u01eb\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01ee\5z"+
		">\2\u01ed\u01ea\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee\u01f0\3\2\2\2\u01ef"+
		"\u01f1\7A\2\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1\u01f2\3\2"+
		"\2\2\u01f2\u01f3\b\23\1\2\u01f3%\3\2\2\2\u01f4\u01f6\7A\2\2\u01f5\u01f4"+
		"\3\2\2\2\u01f5\u01f6\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7\u01f8\7\20\2\2"+
		"\u01f8\u01f9\7A\2\2\u01f9\u01fc\5\u0086D\2\u01fa\u01fb\7A\2\2\u01fb\u01fd"+
		"\5\u008cG\2\u01fc\u01fa\3\2\2\2\u01fc\u01fd\3\2\2\2\u01fd\u0206\3\2\2"+
		"\2\u01fe\u01ff\7A\2\2\u01ff\u0204\5\u0086D\2\u0200\u0202\7A\2\2\u0201"+
		"\u0200\3\2\2\2\u0201\u0202\3\2\2\2\u0202\u0203\3\2\2\2\u0203\u0205\7<"+
		"\2\2\u0204\u0201\3\2\2\2\u0204\u0205\3\2\2\2\u0205\u0207\3\2\2\2\u0206"+
		"\u01fe\3\2\2\2\u0206\u0207\3\2\2\2\u0207\u020c\3\2\2\2\u0208\u020a\7A"+
		"\2\2\u0209\u0208\3\2\2\2\u0209\u020a\3\2\2\2\u020a\u020b\3\2\2\2\u020b"+
		"\u020d\5z>\2\u020c\u0209\3\2\2\2\u020c\u020d\3\2\2\2\u020d\u020f\3\2\2"+
		"\2\u020e\u0210\7A\2\2\u020f\u020e\3\2\2\2\u020f\u0210\3\2\2\2\u0210\u0211"+
		"\3\2\2\2\u0211\u0212\b\24\1\2\u0212\'\3\2\2\2\u0213\u0215\7A\2\2\u0214"+
		"\u0213\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0216\3\2\2\2\u0216\u0217\7\22"+
		"\2\2\u0217\u0218\7A\2\2\u0218\u021d\5\u0086D\2\u0219\u021b\7A\2\2\u021a"+
		"\u0219\3\2\2\2\u021a\u021b\3\2\2\2\u021b\u021c\3\2\2\2\u021c\u021e\5z"+
		">\2\u021d\u021a\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u0220\3\2\2\2\u021f"+
		"\u0221\7A\2\2\u0220\u021f\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0222\3\2"+
		"\2\2\u0222\u0223\b\25\1\2\u0223)\3\2\2\2\u0224\u0226\7A\2\2\u0225\u0224"+
		"\3\2\2\2\u0225\u0226\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u022c\7)\2\2\u0228"+
		"\u022a\7A\2\2\u0229\u0228\3\2\2\2\u0229\u022a\3\2\2\2\u022a\u022b\3\2"+
		"\2\2\u022b\u022d\5z>\2\u022c\u0229\3\2\2\2\u022c\u022d\3\2\2\2\u022d\u022f"+
		"\3\2\2\2\u022e\u0230\7A\2\2\u022f\u022e\3\2\2\2\u022f\u0230\3\2\2\2\u0230"+
		"\u0231\3\2\2\2\u0231\u0232\b\26\1\2\u0232+\3\2\2\2\u0233\u0235\7A\2\2"+
		"\u0234\u0233\3\2\2\2\u0234\u0235\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u0237"+
		"\7\25\2\2\u0237\u0238\7A\2\2\u0238\u0239\5\u0086D\2\u0239\u023a\7A\2\2"+
		"\u023a\u023f\5\u008eH\2\u023b\u023d\7A\2\2\u023c\u023b\3\2\2\2\u023c\u023d"+
		"\3\2\2\2\u023d\u023e\3\2\2\2\u023e\u0240\5z>\2\u023f\u023c\3\2\2\2\u023f"+
		"\u0240\3\2\2\2\u0240\u0242\3\2\2\2\u0241\u0243\7A\2\2\u0242\u0241\3\2"+
		"\2\2\u0242\u0243\3\2\2\2\u0243\u0244\3\2\2\2\u0244\u0245\b\27\1\2\u0245"+
		"-\3\2\2\2\u0246\u0248\7A\2\2\u0247\u0246\3\2\2\2\u0247\u0248\3\2\2\2\u0248"+
		"\u0249\3\2\2\2\u0249\u024b\7/\2\2\u024a\u024c\7A\2\2\u024b\u024a\3\2\2"+
		"\2\u024b\u024c\3\2\2\2\u024c\u024d\3\2\2\2\u024d\u024f\5~@\2\u024e\u0250"+
		"\7A\2\2\u024f\u024e\3\2\2\2\u024f\u0250\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+
		"\u0252\b\30\1\2\u0252/\3\2\2\2\u0253\u0255\7A\2\2\u0254\u0253\3\2\2\2"+
		"\u0254\u0255\3\2\2\2\u0255\u0256\3\2\2\2\u0256\u0258\5z>\2\u0257\u0259"+
		"\7A\2\2\u0258\u0257\3\2\2\2\u0258\u0259\3\2\2\2\u0259\u025a\3\2\2\2\u025a"+
		"\u025b\b\31\1\2\u025b\61\3\2\2\2\u025c\u025e\7A\2\2\u025d\u025c\3\2\2"+
		"\2\u025d\u025e\3\2\2\2\u025e\u025f\3\2\2\2\u025f\u0262\7\24\2\2\u0260"+
		"\u0261\7A\2\2\u0261\u0263\5~@\2\u0262\u0260\3\2\2\2\u0262\u0263\3\2\2"+
		"\2\u0263\u0265\3\2\2\2\u0264\u0266\7A\2\2\u0265\u0264\3\2\2\2\u0265\u0266"+
		"\3\2\2\2\u0266\u0267\3\2\2\2\u0267\u0268\b\32\1\2\u0268\63\3\2\2\2\u0269"+
		"\u026b\7A\2\2\u026a\u0269\3\2\2\2\u026a\u026b\3\2\2\2\u026b\u026c\3\2"+
		"\2\2\u026c\u026e\7\23\2\2\u026d\u026f\7A\2\2\u026e\u026d\3\2\2\2\u026e"+
		"\u026f\3\2\2\2\u026f\65\3\2\2\2\u0270\u0273\58\35\2\u0271\u0273\5:\36"+
		"\2\u0272\u0270\3\2\2\2\u0272\u0271\3\2\2\2\u0273\67\3\2\2\2\u0274\u0276"+
		"\7A\2\2\u0275\u0274\3\2\2\2\u0275\u0276\3\2\2\2\u0276\u0277\3\2\2\2\u0277"+
		"\u0278\7%\2\2\u0278\u0279\7A\2\2\u0279\u027e\5\u008eH\2\u027a\u027c\7"+
		"A\2\2\u027b\u027a\3\2\2\2\u027b\u027c\3\2\2\2\u027c\u027d\3\2\2\2\u027d"+
		"\u027f\5z>\2\u027e\u027b\3\2\2\2\u027e\u027f\3\2\2\2\u027f\u0281\3\2\2"+
		"\2\u0280\u0282\7A\2\2\u0281\u0280\3\2\2\2\u0281\u0282\3\2\2\2\u0282\u0283"+
		"\3\2\2\2\u0283\u0284\b\35\1\2\u02849\3\2\2\2\u0285\u0287\7A\2\2\u0286"+
		"\u0285\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0288\3\2\2\2\u0288\u0289\7%"+
		"\2\2\u0289\u028a\7A\2\2\u028a\u028f\5\u0086D\2\u028b\u028d\7A\2\2\u028c"+
		"\u028b\3\2\2\2\u028c\u028d\3\2\2\2\u028d\u028e\3\2\2\2\u028e\u0290\7<"+
		"\2\2\u028f\u028c\3\2\2\2\u028f\u0290\3\2\2\2\u0290\u0295\3\2\2\2\u0291"+
		"\u0293\7A\2\2\u0292\u0291\3\2\2\2\u0292\u0293\3\2\2\2\u0293\u0294\3\2"+
		"\2\2\u0294\u0296\5z>\2\u0295\u0292\3\2\2\2\u0295\u0296\3\2\2\2\u0296\u0298"+
		"\3\2\2\2\u0297\u0299\7A\2\2\u0298\u0297\3\2\2\2\u0298\u0299\3\2\2\2\u0299"+
		"\u029a\3\2\2\2\u029a\u029b\b\36\1\2\u029b;\3\2\2\2\u029c\u029f\5> \2\u029d"+
		"\u029f\5@!\2\u029e\u029c\3\2\2\2\u029e\u029d\3\2\2\2\u029f=\3\2\2\2\u02a0"+
		"\u02a2\7A\2\2\u02a1\u02a0\3\2\2\2\u02a1\u02a2\3\2\2\2\u02a2\u02a3\3\2"+
		"\2\2\u02a3\u02a4\7&\2\2\u02a4\u02a5\7A\2\2\u02a5\u02aa\5\u008eH\2\u02a6"+
		"\u02a8\7A\2\2\u02a7\u02a6\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8\u02a9\3\2"+
		"\2\2\u02a9\u02ab\5z>\2\u02aa\u02a7\3\2\2\2\u02aa\u02ab\3\2\2\2\u02ab\u02ad"+
		"\3\2\2\2\u02ac\u02ae\7A\2\2\u02ad\u02ac\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae"+
		"\u02af\3\2\2\2\u02af\u02b0\b \1\2\u02b0?\3\2\2\2\u02b1\u02b3\7A\2\2\u02b2"+
		"\u02b1\3\2\2\2\u02b2\u02b3\3\2\2\2\u02b3\u02b4\3\2\2\2\u02b4\u02b5\7&"+
		"\2\2\u02b5\u02b6\7A\2\2\u02b6\u02bb\5\u0086D\2\u02b7\u02b9\7A\2\2\u02b8"+
		"\u02b7\3\2\2\2\u02b8\u02b9\3\2\2\2\u02b9\u02ba\3\2\2\2\u02ba\u02bc\7<"+
		"\2\2\u02bb\u02b8\3\2\2\2\u02bb\u02bc\3\2\2\2\u02bc\u02c1\3\2\2\2\u02bd"+
		"\u02bf\7A\2\2\u02be\u02bd\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c0\3\2"+
		"\2\2\u02c0\u02c2\5z>\2\u02c1\u02be\3\2\2\2\u02c1\u02c2\3\2\2\2\u02c2\u02c4"+
		"\3\2\2\2\u02c3\u02c5\7A\2\2\u02c4\u02c3\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5"+
		"\u02c6\3\2\2\2\u02c6\u02c7\b!\1\2\u02c7A\3\2\2\2\u02c8\u02cb\5D#\2\u02c9"+
		"\u02cb\5F$\2\u02ca\u02c8\3\2\2\2\u02ca\u02c9\3\2\2\2\u02cbC\3\2\2\2\u02cc"+
		"\u02ce\7A\2\2\u02cd\u02cc\3\2\2\2\u02cd\u02ce\3\2\2\2\u02ce\u02cf\3\2"+
		"\2\2\u02cf\u02d0\7\'\2\2\u02d0\u02d1\7A\2\2\u02d1\u02d6\5\u008eH\2\u02d2"+
		"\u02d4\7A\2\2\u02d3\u02d2\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4\u02d5\3\2"+
		"\2\2\u02d5\u02d7\5z>\2\u02d6\u02d3\3\2\2\2\u02d6\u02d7\3\2\2\2\u02d7\u02d9"+
		"\3\2\2\2\u02d8\u02da\7A\2\2\u02d9\u02d8\3\2\2\2\u02d9\u02da\3\2\2\2\u02da"+
		"\u02db\3\2\2\2\u02db\u02dc\b#\1\2\u02dcE\3\2\2\2\u02dd\u02df\7A\2\2\u02de"+
		"\u02dd\3\2\2\2\u02de\u02df\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e1\7\'"+
		"\2\2\u02e1\u02e2\7A\2\2\u02e2\u02e7\5\u0086D\2\u02e3\u02e5\7A\2\2\u02e4"+
		"\u02e3\3\2\2\2\u02e4\u02e5\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e8\7<"+
		"\2\2\u02e7\u02e4\3\2\2\2\u02e7\u02e8\3\2\2\2\u02e8\u02ed\3\2\2\2\u02e9"+
		"\u02eb\7A\2\2\u02ea\u02e9\3\2\2\2\u02ea\u02eb\3\2\2\2\u02eb\u02ec\3\2"+
		"\2\2\u02ec\u02ee\5z>\2\u02ed\u02ea\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02f0"+
		"\3\2\2\2\u02ef\u02f1\7A\2\2\u02f0\u02ef\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1"+
		"\u02f2\3\2\2\2\u02f2\u02f3\b$\1\2\u02f3G\3\2\2\2\u02f4\u02f7\5J&\2\u02f5"+
		"\u02f7\5L\'\2\u02f6\u02f4\3\2\2\2\u02f6\u02f5\3\2\2\2\u02f7I\3\2\2\2\u02f8"+
		"\u02fa\7A\2\2\u02f9\u02f8\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa\u02fb\3\2"+
		"\2\2\u02fb\u02fc\7(\2\2\u02fc\u02fd\7A\2\2\u02fd\u0302\5\u008eH\2\u02fe"+
		"\u0300\7A\2\2\u02ff\u02fe\3\2\2\2\u02ff\u0300\3\2\2\2\u0300\u0301\3\2"+
		"\2\2\u0301\u0303\5z>\2\u0302\u02ff\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u0305"+
		"\3\2\2\2\u0304\u0306\7A\2\2\u0305\u0304\3\2\2\2\u0305\u0306\3\2\2\2\u0306"+
		"\u0307\3\2\2\2\u0307\u0308\b&\1\2\u0308K\3\2\2\2\u0309\u030b\7A\2\2\u030a"+
		"\u0309\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u030c\3\2\2\2\u030c\u030d\7("+
		"\2\2\u030d\u030e\7A\2\2\u030e\u0313\5\u0086D\2\u030f\u0311\7A\2\2\u0310"+
		"\u030f\3\2\2\2\u0310\u0311\3\2\2\2\u0311\u0312\3\2\2\2\u0312\u0314\7<"+
		"\2\2\u0313\u0310\3\2\2\2\u0313\u0314\3\2\2\2\u0314\u0319\3\2\2\2\u0315"+
		"\u0317\7A\2\2\u0316\u0315\3\2\2\2\u0316\u0317\3\2\2\2\u0317\u0318\3\2"+
		"\2\2\u0318\u031a\5z>\2\u0319\u0316\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u031c"+
		"\3\2\2\2\u031b\u031d\7A\2\2\u031c\u031b\3\2\2\2\u031c\u031d\3\2\2\2\u031d"+
		"\u031e\3\2\2\2\u031e\u031f\b\'\1\2\u031fM\3\2\2\2\u0320\u0323\5P)\2\u0321"+
		"\u0323\5R*\2\u0322\u0320\3\2\2\2\u0322\u0321\3\2\2\2\u0323O\3\2\2\2\u0324"+
		"\u0326\7A\2\2\u0325\u0324\3\2\2\2\u0325\u0326\3\2\2\2\u0326\u0327\3\2"+
		"\2\2\u0327\u0328\7-\2\2\u0328\u0329\7A\2\2\u0329\u0332\5\u0086D\2\u032a"+
		"\u032c\7A\2\2\u032b\u032a\3\2\2\2\u032b\u032c\3\2\2\2\u032c\u032d\3\2"+
		"\2\2\u032d\u032f\7<\2\2\u032e\u0330\7A\2\2\u032f\u032e\3\2\2\2\u032f\u0330"+
		"\3\2\2\2\u0330\u0333\3\2\2\2\u0331\u0333\7A\2\2\u0332\u032b\3\2\2\2\u0332"+
		"\u0331\3\2\2\2\u0333\u0334\3\2\2\2\u0334\u0339\5\u0086D\2\u0335\u0337"+
		"\7A\2\2\u0336\u0335\3\2\2\2\u0336\u0337\3\2\2\2\u0337\u0338\3\2\2\2\u0338"+
		"\u033a\7<\2\2\u0339\u0336\3\2\2\2\u0339\u033a\3\2\2\2\u033a\u033c\3\2"+
		"\2\2\u033b\u033d\7A\2\2\u033c\u033b\3\2\2\2\u033c\u033d\3\2\2\2\u033d"+
		"\u033e\3\2\2\2\u033e\u033f\b)\1\2\u033fQ\3\2\2\2\u0340\u0342\7A\2\2\u0341"+
		"\u0340\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0343\3\2\2\2\u0343\u0344\7."+
		"\2\2\u0344\u0345\7A\2\2\u0345\u034e\5\u0086D\2\u0346\u0348\7A\2\2\u0347"+
		"\u0346\3\2\2\2\u0347\u0348\3\2\2\2\u0348\u0349\3\2\2\2\u0349\u034b\7<"+
		"\2\2\u034a\u034c\7A\2\2\u034b\u034a\3\2\2\2\u034b\u034c\3\2\2\2\u034c"+
		"\u034f\3\2\2\2\u034d\u034f\7A\2\2\u034e\u0347\3\2\2\2\u034e\u034d\3\2"+
		"\2\2\u034f\u0350\3\2\2\2\u0350\u0352\5\u008cG\2\u0351\u0353\7A\2\2\u0352"+
		"\u0351\3\2\2\2\u0352\u0353\3\2\2\2\u0353\u0354\3\2\2\2\u0354\u0355\b*"+
		"\1\2\u0355S\3\2\2\2\u0356\u0358\7A\2\2\u0357\u0356\3\2\2\2\u0357\u0358"+
		"\3\2\2\2\u0358\u0359\3\2\2\2\u0359\u035a\7\"\2\2\u035a\u035b\7A\2\2\u035b"+
		"\u035d\5\u0086D\2\u035c\u035e\7A\2\2\u035d\u035c\3\2\2\2\u035d\u035e\3"+
		"\2\2\2\u035e\u035f\3\2\2\2\u035f\u0360\b+\1\2\u0360U\3\2\2\2\u0361\u0363"+
		"\7A\2\2\u0362\u0361\3\2\2\2\u0362\u0363\3\2\2\2\u0363\u0364\3\2\2\2\u0364"+
		"\u0376\7#\2\2\u0365\u0374\7A\2\2\u0366\u0367\7\6\2\2\u0367\u0375\b,\1"+
		"\2\u0368\u0369\7\7\2\2\u0369\u0375\b,\1\2\u036a\u036b\7\b\2\2\u036b\u0375"+
		"\b,\1\2\u036c\u036d\7\t\2\2\u036d\u0375\b,\1\2\u036e\u036f\7\n\2\2\u036f"+
		"\u0375\b,\1\2\u0370\u0371\7\13\2\2\u0371\u0375\b,\1\2\u0372\u0373\7 \2"+
		"\2\u0373\u0375\b,\1\2\u0374\u0366\3\2\2\2\u0374\u0368\3\2\2\2\u0374\u036a"+
		"\3\2\2\2\u0374\u036c\3\2\2\2\u0374\u036e\3\2\2\2\u0374\u0370\3\2\2\2\u0374"+
		"\u0372\3\2\2\2\u0375\u0377\3\2\2\2\u0376\u0365\3\2\2\2\u0376\u0377\3\2"+
		"\2\2\u0377\u0379\3\2\2\2\u0378\u037a\7A\2\2\u0379\u0378\3\2\2\2\u0379"+
		"\u037a\3\2\2\2\u037aW\3\2\2\2\u037b\u037d\7A\2\2\u037c\u037b\3\2\2\2\u037c"+
		"\u037d\3\2\2\2\u037d\u037e\3\2\2\2\u037e\u0380\7$\2\2\u037f\u0381\7A\2"+
		"\2\u0380\u037f\3\2\2\2\u0380\u0381\3\2\2\2\u0381Y\3\2\2\2\u0382\u0384"+
		"\7A\2\2\u0383\u0382\3\2\2\2\u0383\u0384\3\2\2\2\u0384\u0385\3\2\2\2\u0385"+
		"\u0386\7\30\2\2\u0386\u0387\7A\2\2\u0387\u038a\5\u0086D\2\u0388\u0389"+
		"\7A\2\2\u0389\u038b\5\u0088E\2\u038a\u0388\3\2\2\2\u038a\u038b\3\2\2\2"+
		"\u038b\u0390\3\2\2\2\u038c\u038e\7A\2\2\u038d\u038c\3\2\2\2\u038d\u038e"+
		"\3\2\2\2\u038e\u038f\3\2\2\2\u038f\u0391\5z>\2\u0390\u038d\3\2\2\2\u0390"+
		"\u0391\3\2\2\2\u0391\u0393\3\2\2\2\u0392\u0394\7A\2\2\u0393\u0392\3\2"+
		"\2\2\u0393\u0394\3\2\2\2\u0394\u0395\3\2\2\2\u0395\u0396\b.\1\2\u0396"+
		"[\3\2\2\2\u0397\u0399\7A\2\2\u0398\u0397\3\2\2\2\u0398\u0399\3\2\2\2\u0399"+
		"\u039a\3\2\2\2\u039a\u039b\7\31\2\2\u039b\u039c\7A\2\2\u039c\u03a1\5\u0086"+
		"D\2\u039d\u039f\7A\2\2\u039e\u039d\3\2\2\2\u039e\u039f\3\2\2\2\u039f\u03a0"+
		"\3\2\2\2\u03a0\u03a2\5z>\2\u03a1\u039e\3\2\2\2\u03a1\u03a2\3\2\2\2\u03a2"+
		"\u03a4\3\2\2\2\u03a3\u03a5\7A\2\2\u03a4\u03a3\3\2\2\2\u03a4\u03a5\3\2"+
		"\2\2\u03a5\u03a6\3\2\2\2\u03a6\u03a7\b/\1\2\u03a7]\3\2\2\2\u03a8\u03aa"+
		"\7A\2\2\u03a9\u03a8\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ab\3\2\2\2\u03ab"+
		"\u03ad\7\32\2\2\u03ac\u03ae\7A\2\2\u03ad\u03ac\3\2\2\2\u03ad\u03ae\3\2"+
		"\2\2\u03ae_\3\2\2\2\u03af\u03b1\7A\2\2\u03b0\u03af\3\2\2\2\u03b0\u03b1"+
		"\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b4\7\33\2\2\u03b3\u03b5\7A\2\2\u03b4"+
		"\u03b3\3\2\2\2\u03b4\u03b5\3\2\2\2\u03b5a\3\2\2\2\u03b6\u03b8\7A\2\2\u03b7"+
		"\u03b6\3\2\2\2\u03b7\u03b8\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03ba\7\34"+
		"\2\2\u03ba\u03bf\7A\2\2\u03bb\u03bc\7\35\2\2\u03bc\u03c0\b\62\1\2\u03bd"+
		"\u03be\7\36\2\2\u03be\u03c0\b\62\1\2\u03bf\u03bb\3\2\2\2\u03bf\u03bd\3"+
		"\2\2\2\u03c0\u03c1\3\2\2\2\u03c1\u03c6\7A\2\2\u03c2\u03c3\7\37\2\2\u03c3"+
		"\u03c7\b\62\1\2\u03c4\u03c5\7 \2\2\u03c5\u03c7\b\62\1\2\u03c6\u03c2\3"+
		"\2\2\2\u03c6\u03c4\3\2\2\2\u03c7\u03c9\3\2\2\2\u03c8\u03ca\7A\2\2\u03c9"+
		"\u03c8\3\2\2\2\u03c9\u03ca\3\2\2\2\u03cac\3\2\2\2\u03cb\u03cd\7A\2\2\u03cc"+
		"\u03cb\3\2\2\2\u03cc\u03cd\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03cf\7,"+
		"\2\2\u03cf\u03d0\7A\2\2\u03d0\u03d2\5~@\2\u03d1\u03d3\7A\2\2\u03d2\u03d1"+
		"\3\2\2\2\u03d2\u03d3\3\2\2\2\u03d3\u03d4\3\2\2\2\u03d4\u03d5\b\63\1\2"+
		"\u03d5e\3\2\2\2\u03d6\u03d8\7A\2\2\u03d7\u03d6\3\2\2\2\u03d7\u03d8\3\2"+
		"\2\2\u03d8\u03d9\3\2\2\2\u03d9\u03db\7*\2\2\u03da\u03dc\7A\2\2\u03db\u03da"+
		"\3\2\2\2\u03db\u03dc\3\2\2\2\u03dcg\3\2\2\2\u03dd\u03df\7A\2\2\u03de\u03dd"+
		"\3\2\2\2\u03de\u03df\3\2\2\2\u03df\u03e0\3\2\2\2\u03e0\u03e1\7+\2\2\u03e1"+
		"\u03e2\7A\2\2\u03e2\u03e4\5\u008cG\2\u03e3\u03e5\7A\2\2\u03e4\u03e3\3"+
		"\2\2\2\u03e4\u03e5\3\2\2\2\u03e5\u03e6\3\2\2\2\u03e6\u03e7\b\65\1\2\u03e7"+
		"i\3\2\2\2\u03e8\u03ea\7A\2\2\u03e9\u03e8\3\2\2\2\u03e9\u03ea\3\2\2\2\u03ea"+
		"\u03eb\3\2\2\2\u03eb\u03ed\7\60\2\2\u03ec\u03ee\7A\2\2\u03ed\u03ec\3\2"+
		"\2\2\u03ed\u03ee\3\2\2\2\u03eek\3\2\2\2\u03ef\u03f1\7A\2\2\u03f0\u03ef"+
		"\3\2\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f2\3\2\2\2\u03f2\u03f3\7\61\2\2"+
		"\u03f3\u03f4\7A\2\2\u03f4\u03f6\5\u0086D\2\u03f5\u03f7\7A\2\2\u03f6\u03f5"+
		"\3\2\2\2\u03f6\u03f7\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8\u03f9\b\67\1\2"+
		"\u03f9m\3\2\2\2\u03fa\u03fc\7A\2\2\u03fb\u03fa\3\2\2\2\u03fb\u03fc\3\2"+
		"\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03ff\7\63\2\2\u03fe\u0400\7A\2\2\u03ff"+
		"\u03fe\3\2\2\2\u03ff\u0400\3\2\2\2\u0400o\3\2\2\2\u0401\u0402\7\67\2\2"+
		"\u0402\u040a\5x=\2\u0403\u0404\7\67\2\2\u0404\u040a\5v<\2\u0405\u0406"+
		"\7\67\2\2\u0406\u040a\5t;\2\u0407\u0408\7\67\2\2\u0408\u040a\5r:\2\u0409"+
		"\u0401\3\2\2\2\u0409\u0403\3\2\2\2\u0409\u0405\3\2\2\2\u0409\u0407\3\2"+
		"\2\2\u040aq\3\2\2\2\u040b\u040d\7A\2\2\u040c\u040b\3\2\2\2\u040c\u040d"+
		"\3\2\2\2\u040d\u040e\3\2\2\2\u040e\u0415\7\65\2\2\u040f\u0410\7A\2\2\u0410"+
		"\u0411\5\u0088E\2\u0411\u0412\b:\1\2\u0412\u0414\3\2\2\2\u0413\u040f\3"+
		"\2\2\2\u0414\u0417\3\2\2\2\u0415\u0413\3\2\2\2\u0415\u0416\3\2\2\2\u0416"+
		"\u0419\3\2\2\2\u0417\u0415\3\2\2\2\u0418\u041a\7A\2\2\u0419\u0418\3\2"+
		"\2\2\u0419\u041a\3\2\2\2\u041as\3\2\2\2\u041b\u041d\7A\2\2\u041c\u041b"+
		"\3\2\2\2\u041c\u041d\3\2\2\2\u041d\u041e\3\2\2\2\u041e\u0425\7\66\2\2"+
		"\u041f\u0420\7A\2\2\u0420\u0421\5\u0088E\2\u0421\u0422\b;\1\2\u0422\u0424"+
		"\3\2\2\2\u0423\u041f\3\2\2\2\u0424\u0427\3\2\2\2\u0425\u0423\3\2\2\2\u0425"+
		"\u0426\3\2\2\2\u0426\u0429\3\2\2\2\u0427\u0425\3\2\2\2\u0428\u042a\7A"+
		"\2\2\u0429\u0428\3\2\2\2\u0429\u042a\3\2\2\2\u042au\3\2\2\2\u042b\u042d"+
		"\7A\2\2\u042c\u042b\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042e\3\2\2\2\u042e"+
		"\u042f\7\62\2\2\u042f\u0430\7A\2\2\u0430\u0433\5\u008cG\2\u0431\u0432"+
		"\7A\2\2\u0432\u0434\5\u008cG\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2"+
		"\u0434\u0436\3\2\2\2\u0435\u0437\7A\2\2\u0436\u0435\3\2\2\2\u0436\u0437"+
		"\3\2\2\2\u0437\u0438\3\2\2\2\u0438\u0439\b<\1\2\u0439w\3\2\2\2\u043a\u043c"+
		"\7A\2\2\u043b\u043a\3\2\2\2\u043b\u043c\3\2\2\2\u043c\u043d\3\2\2\2\u043d"+
		"\u043f\7\64\2\2\u043e\u0440\7A\2\2\u043f\u043e\3\2\2\2\u043f\u0440\3\2"+
		"\2\2\u0440y\3\2\2\2\u0441\u0442\7:\2\2\u0442\u045f\b>\1\2\u0443\u0444"+
		"\5\u0088E\2\u0444\u0445\b>\1\2\u0445\u045e\3\2\2\2\u0446\u0447\5\u008c"+
		"G\2\u0447\u0448\b>\1\2\u0448\u045e\3\2\2\2\u0449\u044a\5\u0080A\2\u044a"+
		"\u044b\b>\1\2\u044b\u045e\3\2\2\2\u044c\u044d\5\u008aF\2\u044d\u044e\b"+
		">\1\2\u044e\u045e\3\2\2\2\u044f\u0450\7<\2\2\u0450\u045e\b>\1\2\u0451"+
		"\u0452\7A\2\2\u0452\u045e\b>\1\2\u0453\u0454\79\2\2\u0454\u045e\b>\1\2"+
		"\u0455\u0456\78\2\2\u0456\u045e\b>\1\2\u0457\u0458\7:\2\2\u0458\u045e"+
		"\b>\1\2\u0459\u045a\7;\2\2\u045a\u045e\b>\1\2\u045b\u045c\7=\2\2\u045c"+
		"\u045e\b>\1\2\u045d\u0443\3\2\2\2\u045d\u0446\3\2\2\2\u045d\u0449\3\2"+
		"\2\2\u045d\u044c\3\2\2\2\u045d\u044f\3\2\2\2\u045d\u0451\3\2\2\2\u045d"+
		"\u0453\3\2\2\2\u045d\u0455\3\2\2\2\u045d\u0457\3\2\2\2\u045d\u0459\3\2"+
		"\2\2\u045d\u045b\3\2\2\2\u045e\u0461\3\2\2\2\u045f\u045d\3\2\2\2\u045f"+
		"\u0460\3\2\2\2\u0460\u0462\3\2\2\2\u0461\u045f\3\2\2\2\u0462\u0463\7;"+
		"\2\2\u0463{\3\2\2\2\u0464\u0466\7A\2\2\u0465\u0464\3\2\2\2\u0465\u0466"+
		"\3\2\2\2\u0466\u046e\3\2\2\2\u0467\u0469\7A\2\2\u0468\u0467\3\2\2\2\u0468"+
		"\u0469\3\2\2\2\u0469\u046a\3\2\2\2\u046a\u046c\5z>\2\u046b\u046d\7A\2"+
		"\2\u046c\u046b\3\2\2\2\u046c\u046d\3\2\2\2\u046d\u046f\3\2\2\2\u046e\u0468"+
		"\3\2\2\2\u046e\u046f\3\2\2\2\u046f\u0470\3\2\2\2\u0470\u0471\b?\1\2\u0471"+
		"}\3\2\2\2\u0472\u0474\13\2\2\2\u0473\u0472\3\2\2\2\u0474\u0477\3\2\2\2"+
		"\u0475\u0476\3\2\2\2\u0475\u0473\3\2\2\2\u0476\177\3\2\2\2\u0477\u0475"+
		"\3\2\2\2\u0478\u0479\5\u0082B\2\u0479\u047a\bA\1\2\u047a\u047f\3\2\2\2"+
		"\u047b\u047c\5\u0084C\2\u047c\u047d\bA\1\2\u047d\u047f\3\2\2\2\u047e\u0478"+
		"\3\2\2\2\u047e\u047b\3\2\2\2\u047f\u0081\3\2\2\2\u0480\u0481\79\2\2\u0481"+
		"\u0482\5\u0086D\2\u0482\u0483\bB\1\2\u0483\u0083\3\2\2\2\u0484\u0485\7"+
		"8\2\2\u0485\u0486\5\u0086D\2\u0486\u0487\bC\1\2\u0487\u0085\3\2\2\2\u0488"+
		"\u0489\5\u008cG\2\u0489\u048a\7<\2\2\u048a\u048b\5\u0088E\2\u048b\u048c"+
		"\bD\1\2\u048c\u0491\3\2\2\2\u048d\u048e\5\u0088E\2\u048e\u048f\bD\1\2"+
		"\u048f\u0491\3\2\2\2\u0490\u0488\3\2\2\2\u0490\u048d\3\2\2\2\u0491\u0087"+
		"\3\2\2\2\u0492\u0493\7>\2\2\u0493\u0494\bE\1\2\u0494\u0089\3\2\2\2\u0495"+
		"\u0496\7@\2\2\u0496\u0497\bF\1\2\u0497\u008b\3\2\2\2\u0498\u0499\7?\2"+
		"\2\u0499\u049a\bG\1\2\u049a\u008d\3\2\2\2\u049b\u049c\7\6\2\2\u049c\u04a8"+
		"\bH\1\2\u049d\u049e\7\7\2\2\u049e\u04a8\bH\1\2\u049f\u04a0\7\b\2\2\u04a0"+
		"\u04a8\bH\1\2\u04a1\u04a2\7\t\2\2\u04a2\u04a8\bH\1\2\u04a3\u04a4\7\n\2"+
		"\2\u04a4\u04a8\bH\1\2\u04a5\u04a6\7\13\2\2\u04a6\u04a8\bH\1\2\u04a7\u049b"+
		"\3\2\2\2\u04a7\u049d\3\2\2\2\u04a7\u049f\3\2\2\2\u04a7\u04a1\3\2\2\2\u04a7"+
		"\u04a3\3\2\2\2\u04a7\u04a5\3\2\2\2\u04a8\u008f\3\2\2\2\u00db\u00b9\u00bc"+
		"\u00ca\u00cd\u00d0\u00d3\u00d8\u00e0\u00e5\u00eb\u00f0\u00f6\u00fc\u00ff"+
		"\u0105\u0108\u010b\u0110\u0118\u011b\u011e\u0121\u0124\u0129\u0131\u0135"+
		"\u0137\u013a\u013d\u0142\u0148\u014b\u014e\u0153\u015b\u015e\u0161\u0166"+
		"\u016a\u0170\u0173\u017a\u017d\u0180\u0183\u0186\u0189\u018e\u0195\u0198"+
		"\u019b\u019e\u01a1\u01a4\u01a9\u01af\u01b2\u01b5\u01ba\u01be\u01c2\u01c6"+
		"\u01c9\u01cc\u01d1\u01d9\u01de\u01e7\u01ea\u01ed\u01f0\u01f5\u01fc\u0201"+
		"\u0204\u0206\u0209\u020c\u020f\u0214\u021a\u021d\u0220\u0225\u0229\u022c"+
		"\u022f\u0234\u023c\u023f\u0242\u0247\u024b\u024f\u0254\u0258\u025d\u0262"+
		"\u0265\u026a\u026e\u0272\u0275\u027b\u027e\u0281\u0286\u028c\u028f\u0292"+
		"\u0295\u0298\u029e\u02a1\u02a7\u02aa\u02ad\u02b2\u02b8\u02bb\u02be\u02c1"+
		"\u02c4\u02ca\u02cd\u02d3\u02d6\u02d9\u02de\u02e4\u02e7\u02ea\u02ed\u02f0"+
		"\u02f6\u02f9\u02ff\u0302\u0305\u030a\u0310\u0313\u0316\u0319\u031c\u0322"+
		"\u0325\u032b\u032f\u0332\u0336\u0339\u033c\u0341\u0347\u034b\u034e\u0352"+
		"\u0357\u035d\u0362\u0374\u0376\u0379\u037c\u0380\u0383\u038a\u038d\u0390"+
		"\u0393\u0398\u039e\u03a1\u03a4\u03a9\u03ad\u03b0\u03b4\u03b7\u03bf\u03c6"+
		"\u03c9\u03cc\u03d2\u03d7\u03db\u03de\u03e4\u03e9\u03ed\u03f0\u03f6\u03fb"+
		"\u03ff\u0409\u040c\u0415\u0419\u041c\u0425\u0429\u042c\u0433\u0436\u043b"+
		"\u043f\u045d\u045f\u0465\u0468\u046c\u046e\u0475\u047e\u0490\u04a7";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}